Ignore:
Timestamp:
12/12/24 17:06:06 (5 weeks ago)
Author:
stefan toskovski <stefantoska84@…>
Branches:
main
Parents:
d565449
Message:

Pred finalna verzija

Location:
imaps-frontend/node_modules/eslint-plugin-react/lib/rules
Files:
209 added
67 edited

Legend:

Unmodified
Added
Removed

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/boolean-prop-naming.js

    rd565449 r0c6b92a  
    1111const Components = require('../util/Components');
    1212const propsUtil = require('../util/props');
     13const astUtil = require('../util/ast');
    1314const docsUrl = require('../util/docsUrl');
    1415const propWrapperUtil = require('../util/propWrapper');
    … …  
    1819const getSourceCode = eslintUtil.getSourceCode;
    1920const getText = eslintUtil.getText;
     21
     22/**
     23 * Checks if prop is nested
     24 * @param {Object} prop Property object, single prop type declaration
     25 * @returns {boolean}
     26 */
     27function nestedPropTypes(prop) {
     28  return (
     29    prop.type === 'Property'
     30    && astUtil.isCallExpression(prop.value)
     31  );
     32}
    2033
    2134// ------------------------------------------------------------------------------
    … …  
    129142     * Checks if prop is declared in flow way
    130143     * @param {Object} prop Property object, single prop type declaration
    131      * @returns {Boolean}
     144     * @returns {boolean}
    132145     */
    133146    function flowCheck(prop) {
    … …  
    142155     * Checks if prop is declared in regular way
    143156     * @param {Object} prop Property object, single prop type declaration
    144      * @returns {Boolean}
     157     * @returns {boolean}
    145158     */
    146159    function regularCheck(prop) {
    … …  
    164177
    165178    /**
    166      * Checks if prop is nested
    167      * @param {Object} prop Property object, single prop type declaration
    168      * @returns {Boolean}
    169      */
    170     function nestedPropTypes(prop) {
    171       return (
    172         prop.type === 'Property'
    173         && prop.value.type === 'CallExpression'
    174       );
    175     }
    176 
    177     /**
    178179     * Runs recursive check on all proptypes
    179180     * @param {Array} proptypes A list of Property object (for each proptype defined)
    … …  
    181182     */
    182183    function runCheck(proptypes, addInvalidProp) {
    183       (proptypes || []).forEach((prop) => {
    184         if (config.validateNested && nestedPropTypes(prop)) {
    185           runCheck(prop.value.arguments[0].properties, addInvalidProp);
    186           return;
    187         }
    188         if (flowCheck(prop) || regularCheck(prop) || tsCheck(prop)) {
    189           addInvalidProp(prop);
    190         }
    191       });
     184      if (proptypes) {
     185        proptypes.forEach((prop) => {
     186          if (config.validateNested && nestedPropTypes(prop)) {
     187            runCheck(prop.value.arguments[0].properties, addInvalidProp);
     188            return;
     189          }
     190          if (flowCheck(prop) || regularCheck(prop) || tsCheck(prop)) {
     191            addInvalidProp(prop);
     192          }
     193        });
     194      }
    192195    }
    193196
    … …  
    257260      }
    258261
    259       const annotationTypeParams = component.node.parent.id.typeAnnotation.typeAnnotation.typeParameters;
     262      const annotationTypeArguments = propsUtil.getTypeArguments(
     263        component.node.parent.id.typeAnnotation.typeAnnotation
     264      );
    260265      if (
    261         annotationTypeParams && (
    262           annotationTypeParams.type === 'TSTypeParameterInstantiation'
    263           || annotationTypeParams.type === 'TypeParameterInstantiation'
     266        annotationTypeArguments && (
     267          annotationTypeArguments.type === 'TSTypeParameterInstantiation'
     268          || annotationTypeArguments.type === 'TypeParameterInstantiation'
    264269        )
    265270      ) {
    266         return annotationTypeParams.params.find(
     271        return annotationTypeArguments.params.find(
    267272          (param) => param.type === 'TSTypeReference' || param.type === 'GenericTypeAnnotation'
    268273        );
    … …  
    310315        if (
    311316          node.value
    312           && node.value.type === 'CallExpression'
     317          && astUtil.isCallExpression(node.value)
    313318          && propWrapperUtil.isPropWrapperFunction(
    314319            context,
    … …  
    336341        const right = node.parent.right;
    337342        if (
    338           right.type === 'CallExpression'
     343          astUtil.isCallExpression(right)
    339344          && propWrapperUtil.isPropWrapperFunction(
    340345            context,

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/button-has-type.js

    rd565449 r0c6b92a  
    2929};
    3030
     31/** @type {import('eslint').Rule.RuleModule} */
    3132module.exports = {
    3233  meta: {
    … …  
    150151
    151152        const props = node.arguments[1].properties;
    152         const typeProp = props.find((prop) => prop.key && prop.key.name === 'type');
     153        const typeProp = props.find((prop) => (
     154          'key' in prop
     155          && prop.key
     156          && 'name' in prop.key
     157          && prop.key.name === 'type'
     158        ));
    153159
    154160        if (!typeProp) {
    … …  
    157163        }
    158164
    159         checkExpression(node, typeProp.value);
     165        checkExpression(node, 'value' in typeProp ? typeProp.value : undefined);
    160166      },
    161167    };

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/checked-requires-onchange-or-readonly.js

    rd565449 r0c6b92a  
    2525
    2626/**
    27  * @param {string[]} properties
     27 * @param {object[]} properties
    2828 * @param {string} keyName
    2929 * @returns {Set<string>}
    … …  
    4242}
    4343
     44/** @type {import('eslint').Rule.RuleModule} */
    4445module.exports = {
    4546  meta: {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/destructuring-assignment.js

    rd565449 r0c6b92a  
    182182    }
    183183
     184    // valid-jsdoc cannot read function types
     185    // eslint-disable-next-line valid-jsdoc
     186    /**
     187     * Find a parent that satisfy the given predicate
     188     * @param {ASTNode} node
     189     * @param {(node: ASTNode) => boolean} predicate
     190     * @returns {ASTNode | undefined}
     191     */
     192    function findParent(node, predicate) {
     193      let n = node;
     194      while (n) {
     195        if (predicate(n)) {
     196          return n;
     197        }
     198        n = n.parent;
     199      }
     200      return undefined;
     201    }
     202
    184203    return {
    185204
    … …  
    197216
    198217      MemberExpression(node) {
    199         let scope = getScope(context, node);
    200         let SFCComponent = components.get(scope.block);
    201         while (!SFCComponent && scope.upper && scope.upper !== scope) {
    202           SFCComponent = components.get(scope.upper.block);
    203           scope = scope.upper;
    204         }
     218        const SFCComponent = utils.getParentStatelessComponent(node);
    205219        if (SFCComponent) {
    206220          handleSFCUsage(node);
    … …  
    210224        if (classComponent) {
    211225          handleClassUsage(node);
     226        }
     227      },
     228
     229      TSQualifiedName(node) {
     230        if (configuration !== 'always') {
     231          return;
     232        }
     233        // handle `typeof props.a.b`
     234        if (node.left.type === 'Identifier'
     235          && node.left.name === sfcParams.propsName()
     236          && findParent(node, (n) => n.type === 'TSTypeQuery')
     237          && utils.getParentStatelessComponent(node)
     238        ) {
     239          report(context, messages.useDestructAssignment, 'useDestructAssignment', {
     240            node,
     241            data: {
     242              type: 'props',
     243            },
     244          });
    212245        }
    213246      },
    … …  
    258291            return;
    259292          }
     293
    260294          // Skip if props is used elsewhere
    261295          if (propsRefs.length > 1) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/display-name.js

    rd565449 r0c6b92a  
    7474     * Checks if React.forwardRef is nested inside React.memo
    7575     * @param {ASTNode} node The AST node being checked.
    76      * @returns {Boolean} True if React.forwardRef is nested inside React.memo, false if not.
     76     * @returns {boolean} True if React.forwardRef is nested inside React.memo, false if not.
    7777     */
    7878    function isNestedMemo(node) {
    79       const argumentIsCallExpression = node.arguments && node.arguments[0] && node.arguments[0].type === 'CallExpression';
    80 
    81       return node.type === 'CallExpression' && argumentIsCallExpression && utils.isPragmaComponentWrapper(node);
     79      return astUtil.isCallExpression(node)
     80        && node.arguments
     81        && astUtil.isCallExpression(node.arguments[0])
     82        && utils.isPragmaComponentWrapper(node);
    8283    }
    8384
    … …  
    112113     * Checks if the component have a name set by the transpiler
    113114     * @param {ASTNode} node The AST node being checked.
    114      * @returns {Boolean} True if component has a name, false if not.
     115     * @returns {boolean} True if component has a name, false if not.
    115116     */
    116117    function hasTranspilerName(node) {
    … …  
    199200          return;
    200201        }
    201         markDisplayNameAsDeclared(component.node.type === 'TSAsExpression' ? component.node.expression : component.node);
     202        markDisplayNameAsDeclared(astUtil.unwrapTSAsExpression(component.node));
    202203      },
    203204

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/forbid-component-props.js

    rd565449 r0c6b92a  
    5353                    items: { type: 'string' },
    5454                  },
     55                  allowedForPatterns: {
     56                    type: 'array',
     57                    uniqueItems: true,
     58                    items: { type: 'string' },
     59                  },
    5560                  message: { type: 'string' },
    5661                },
    … …  
    6772                    items: { type: 'string' },
    6873                  },
    69                   message: { type: 'string' },
    70                 },
    71                 required: ['disallowedFor'],
    72                 additionalProperties: false,
    73               },
    74 
     74                  disallowedForPatterns: {
     75                    type: 'array',
     76                    uniqueItems: true,
     77                    minItems: 1,
     78                    items: { type: 'string' },
     79                  },
     80                  message: { type: 'string' },
     81                },
     82                anyOf: [
     83                  { required: ['disallowedFor'] },
     84                  { required: ['disallowedForPatterns'] },
     85                ],
     86                additionalProperties: false,
     87              },
    7588              {
    7689                type: 'object',
    … …  
    8295                    items: { type: 'string' },
    8396                  },
     97                  allowedForPatterns: {
     98                    type: 'array',
     99                    uniqueItems: true,
     100                    items: { type: 'string' },
     101                  },
    84102                  message: { type: 'string' },
    85103                },
    … …  
    96114                    items: { type: 'string' },
    97115                  },
    98                   message: { type: 'string' },
    99                 },
    100                 required: ['disallowedFor'],
     116                  disallowedForPatterns: {
     117                    type: 'array',
     118                    uniqueItems: true,
     119                    minItems: 1,
     120                    items: { type: 'string' },
     121                  },
     122                  message: { type: 'string' },
     123                },
     124                anyOf: [
     125                  { required: ['disallowedFor'] },
     126                  { required: ['disallowedForPatterns'] },
     127                ],
    101128                additionalProperties: false,
    102129              },
    … …  
    115142      const prop = propName || propPattern;
    116143      const options = {
    117         allowList: typeof value === 'string' ? [] : (value.allowedFor || []),
    118         disallowList: typeof value === 'string' ? [] : (value.disallowedFor || []),
     144        allowList: [].concat(value.allowedFor || []),
     145        allowPatternList: [].concat(value.allowedForPatterns || []),
     146        disallowList: [].concat(value.disallowedFor || []),
     147        disallowPatternList: [].concat(value.disallowedForPatterns || []),
    119148        message: typeof value === 'string' ? null : value.message,
    120149        isPattern: !!value.propNamePattern,
    … …  
    141170      }
    142171
     172      function checkIsTagForbiddenByAllowOptions() {
     173        if (options.allowList.indexOf(tagName) !== -1) {
     174          return false;
     175        }
     176
     177        if (options.allowPatternList.length === 0) {
     178          return true;
     179        }
     180
     181        return options.allowPatternList.every(
     182          (pattern) => !minimatch(tagName, pattern)
     183        );
     184      }
     185
     186      function checkIsTagForbiddenByDisallowOptions() {
     187        if (options.disallowList.indexOf(tagName) !== -1) {
     188          return true;
     189        }
     190
     191        if (options.disallowPatternList.length === 0) {
     192          return false;
     193        }
     194
     195        return options.disallowPatternList.some(
     196          (pattern) => minimatch(tagName, pattern)
     197        );
     198      }
     199
     200      const hasDisallowOptions = options.disallowList.length > 0 || options.disallowPatternList.length > 0;
     201
    143202      // disallowList should have a least one item (schema configuration)
    144       const isTagForbidden = options.disallowList.length > 0
    145         ? options.disallowList.indexOf(tagName) !== -1
    146         : options.allowList.indexOf(tagName) === -1;
     203      const isTagForbidden = hasDisallowOptions
     204        ? checkIsTagForbiddenByDisallowOptions()
     205        : checkIsTagForbiddenByAllowOptions();
    147206
    148207      // if the tagName is undefined (`<this.something>`), we assume it's a forbidden element

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/forbid-elements.js

    rd565449 r0c6b92a  
    2121};
    2222
     23/** @type {import('eslint').Rule.RuleModule} */
    2324module.exports = {
    2425  meta: {
    … …  
    106107        }
    107108
    108         const argType = argument.type;
    109 
    110         if (argType === 'Identifier' && /^[A-Z_]/.test(argument.name)) {
     109        if (argument.type === 'Identifier' && /^[A-Z_]/.test(argument.name)) {
    111110          reportIfForbidden(argument.name, argument);
    112         } else if (argType === 'Literal' && /^[a-z][^.]*$/.test(argument.value)) {
     111        } else if (argument.type === 'Literal' && /^[a-z][^.]*$/.test(String(argument.value))) {
    113112          reportIfForbidden(argument.value, argument);
    114         } else if (argType === 'MemberExpression') {
     113        } else if (argument.type === 'MemberExpression') {
    115114          reportIfForbidden(getText(context, argument), argument);
    116115        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/forbid-foreign-prop-types.js

    rd565449 r0c6b92a  
    1414};
    1515
     16/** @type {import('eslint').Rule.RuleModule} */
    1617module.exports = {
    1718  meta: {
    … …  
    109110            && !isAllowedAssignment(node)
    110111          )) || (
     112            // @ts-expect-error The JSXText type is not present in the estree type definitions
    111113            (node.property.type === 'Literal' || node.property.type === 'JSXText')
     114            && 'value' in node.property
    112115            && node.property.value === 'propTypes'
    113116            && !ast.isAssignmentLHS(node)
    … …  
    122125
    123126      ObjectPattern(node) {
    124         const propTypesNode = node.properties.find((property) => property.type === 'Property' && property.key.name === 'propTypes');
     127        const propTypesNode = node.properties.find((property) => (
     128          property.type === 'Property'
     129          && 'name' in property.key
     130          && property.key.name === 'propTypes'
     131        ));
    125132
    126133        if (propTypesNode) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/forbid-prop-types.js

    rd565449 r0c6b92a  
    2727};
    2828
     29/** @type {import('eslint').Rule.RuleModule} */
    2930module.exports = {
    3031  meta: {
    … …  
    135136            value = value.object;
    136137          }
    137           if (value.type === 'CallExpression') {
     138          if (astUtil.isCallExpression(value)) {
    138139            if (!isPropTypesPackage(value.callee)) {
    139140              return;
    … …  
    159160
    160161    function checkNode(node) {
    161       switch (node && node.type) {
    162         case 'ObjectExpression':
    163           checkProperties(node.properties);
    164           break;
    165         case 'Identifier': {
    166           const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
    167           if (propTypesObject && propTypesObject.properties) {
    168             checkProperties(propTypesObject.properties);
    169           }
    170           break;
    171         }
    172         case 'CallExpression': {
    173           const innerNode = node.arguments && node.arguments[0];
    174           if (
    175             propWrapperUtil.isPropWrapperFunction(context, getText(context, node.callee))
     162      if (!node) {
     163        return;
     164      }
     165
     166      if (node.type === 'ObjectExpression') {
     167        checkProperties(node.properties);
     168      } else if (node.type === 'Identifier') {
     169        const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
     170        if (propTypesObject && propTypesObject.properties) {
     171          checkProperties(propTypesObject.properties);
     172        }
     173      } else if (astUtil.isCallExpression(node)) {
     174        const innerNode = node.arguments && node.arguments[0];
     175        if (
     176          propWrapperUtil.isPropWrapperFunction(context, getText(context, node.callee))
    176177            && innerNode
    177           ) {
    178             checkNode(innerNode);
    179           }
    180           break;
    181         }
    182         default:
    183           break;
     178        ) {
     179          checkNode(innerNode);
     180        }
    184181      }
    185182    }
    … …  
    197194          if (node.specifiers.length >= 1) {
    198195            const propTypesSpecifier = node.specifiers.find((specifier) => (
    199               specifier.imported && specifier.imported.name === 'PropTypes'
     196              'imported' in specifier
     197              && specifier.imported
     198              && specifier.imported.name === 'PropTypes'
    200199            ));
    201200            if (propTypesSpecifier) {
    … …  
    233232        }
    234233
    235         checkNode(node.parent.right);
     234        checkNode('right' in node.parent && node.parent.right);
    236235      },
    237236
    238237      CallExpression(node) {
    239238        if (
    240           node.callee.object
     239          node.callee.type === 'MemberExpression'
     240          && node.callee.object
    241241          && !isPropTypesPackage(node.callee.object)
    242242          && !propsUtil.isPropTypesDeclaration(node.callee)
    … …  
    247247        if (
    248248          node.arguments.length > 0
    249           && (node.callee.name === 'shape' || astUtil.getPropertyName(node.callee) === 'shape')
    250         ) {
    251           checkProperties(node.arguments[0].properties);
     249          && (
     250            ('name' in node.callee && node.callee.name === 'shape')
     251            || astUtil.getPropertyName(node.callee) === 'shape'
     252          )
     253        ) {
     254          checkProperties('properties' in node.arguments[0] && node.arguments[0].properties);
    252255        }
    253256      },
    … …  
    272275      ObjectExpression(node) {
    273276        node.properties.forEach((property) => {
    274           if (!property.key) {
     277          if (!('key' in property) || !property.key) {
    275278            return;
    276279          }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/function-component-definition.js

    rd565449 r0c6b92a  
    1111const reportC = require('../util/report');
    1212const getText = require('../util/eslint').getText;
     13const propsUtil = require('../util/props');
    1314
    1415// ------------------------------------------------------------------------------
    … …  
    3536
    3637function hasOneUnconstrainedTypeParam(node) {
    37   const nodeTypeParams = node.typeParameters;
    38 
    39   return nodeTypeParams
    40     && nodeTypeParams.params
    41     && nodeTypeParams.params.length === 1
    42     && !nodeTypeParams.params[0].constraint;
     38  const nodeTypeArguments = propsUtil.getTypeArguments(node);
     39
     40  return nodeTypeArguments
     41    && nodeTypeArguments.params
     42    && nodeTypeArguments.params.length === 1
     43    && !nodeTypeArguments.params[0].constraint;
    4344}
    4445
    … …  
    203204      }
    204205
     206      const nodeTypeArguments = propsUtil.getTypeArguments(node);
    205207      return (fixer) => fixer.replaceTextRange(
    206208        options.range,
    207209        buildFunction(options.template, {
    208210          typeAnnotation,
    209           typeParams: getNodeText(node.typeParameters, source),
     211          typeParams: getNodeText(nodeTypeArguments, source),
    210212          params: getParams(node, source),
    211213          returnType: getNodeText(node.returnType, source),

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/hook-use-state.js

    rd565449 r0c6b92a  
    2727};
    2828
     29/** @type {import('eslint').Rule.RuleModule} */
    2930module.exports = {
    3031  meta: {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/index.js

    rd565449 r0c6b92a  
    1616  'forbid-foreign-prop-types': require('./forbid-foreign-prop-types'),
    1717  'forbid-prop-types': require('./forbid-prop-types'),
     18  'forward-ref-uses-ref': require('./forward-ref-uses-ref'),
    1819  'function-component-definition': require('./function-component-definition'),
    1920  'hook-use-state': require('./hook-use-state'),

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-closing-bracket-location.js

    rd565449 r0c6b92a  
    2121};
    2222
     23/** @type {import('eslint').Rule.RuleModule} */
    2324module.exports = {
    2425  meta: {
    … …  
    101102     * Get expected location for the closing bracket
    102103     * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
    103      * @return {String} Expected location for the closing bracket
     104     * @return {string} Expected location for the closing bracket
    104105     */
    105106    function getExpectedLocation(tokens) {
    … …  
    122123     * expected location.
    123124     * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
    124      * @param {String} expectedLocation Expected location for the closing bracket
     125     * @param {string} expectedLocation Expected location for the closing bracket
    125126     * @return {?Number} The correct column for the closing bracket, or null
    126127     */
    … …  
    141142     * Check if the closing bracket is correctly located
    142143     * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
    143      * @param {String} expectedLocation Expected location for the closing bracket
    144      * @return {Boolean} True if the closing bracket is correctly located, false if not
     144     * @param {string} expectedLocation Expected location for the closing bracket
     145     * @return {boolean} True if the closing bracket is correctly located, false if not
    145146     */
    146147    function hasCorrectLocation(tokens, expectedLocation) {
    … …  
    164165     * Get the characters used for indentation on the line to be matched
    165166     * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
    166      * @param {String} expectedLocation Expected location for the closing bracket
    167      * @param {Number} [correctColumn] Expected column for the closing bracket. Default to 0
    168      * @return {String} The characters used for indentation
     167     * @param {string} expectedLocation Expected location for the closing bracket
     168     * @param {number} [correctColumn] Expected column for the closing bracket. Default to 0
     169     * @return {string} The characters used for indentation
    169170     */
    170171    function getIndentation(tokens, expectedLocation, correctColumn) {
    … …  
    236237     *
    237238     * @param {ASTNode} node The AST node being checked.
    238      * @returns {String} Unique ID (based on its range)
     239     * @returns {string} Unique ID (based on its range)
    239240     */
    240241    function getOpeningElementId(node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-curly-brace-presence.js

    rd565449 r0c6b92a  
    3131];
    3232const DEFAULT_CONFIG = { props: OPTION_NEVER, children: OPTION_NEVER, propElementValues: OPTION_IGNORE };
     33
     34const HTML_ENTITY_REGEX = () => /&[A-Za-z\d#]+;/g;
     35
     36function containsLineTerminators(rawStringValue) {
     37  return /[\n\r\u2028\u2029]/.test(rawStringValue);
     38}
     39
     40function containsBackslash(rawStringValue) {
     41  return arrayIncludes(rawStringValue, '\\');
     42}
     43
     44function containsHTMLEntity(rawStringValue) {
     45  return HTML_ENTITY_REGEX().test(rawStringValue);
     46}
     47
     48function containsOnlyHtmlEntities(rawStringValue) {
     49  return rawStringValue.replace(HTML_ENTITY_REGEX(), '').trim() === '';
     50}
     51
     52function containsDisallowedJSXTextChars(rawStringValue) {
     53  return /[{<>}]/.test(rawStringValue);
     54}
     55
     56function containsQuoteCharacters(value) {
     57  return /['"]/.test(value);
     58}
     59
     60function containsMultilineComment(value) {
     61  return /\/\*/.test(value);
     62}
     63
     64function escapeDoubleQuotes(rawStringValue) {
     65  return rawStringValue.replace(/\\"/g, '"').replace(/"/g, '\\"');
     66}
     67
     68function escapeBackslashes(rawStringValue) {
     69  return rawStringValue.replace(/\\/g, '\\\\');
     70}
     71
     72function needToEscapeCharacterForJSX(raw, node) {
     73  return (
     74    containsBackslash(raw)
     75    || containsHTMLEntity(raw)
     76    || (node.parent.type !== 'JSXAttribute' && containsDisallowedJSXTextChars(raw))
     77  );
     78}
     79
     80function containsWhitespaceExpression(child) {
     81  if (child.type === 'JSXExpressionContainer') {
     82    const value = child.expression.value;
     83    return value ? jsxUtil.isWhiteSpaces(value) : false;
     84  }
     85  return false;
     86}
     87
     88function isLineBreak(text) {
     89  return containsLineTerminators(text) && text.trim() === '';
     90}
     91
     92function wrapNonHTMLEntities(text) {
     93  const HTML_ENTITY = '<HTML_ENTITY>';
     94  const withCurlyBraces = text.split(HTML_ENTITY_REGEX()).map((word) => (
     95    word === '' ? '' : `{${JSON.stringify(word)}}`
     96  )).join(HTML_ENTITY);
     97
     98  const htmlEntities = text.match(HTML_ENTITY_REGEX());
     99  return htmlEntities.reduce((acc, htmlEntity) => (
     100    acc.replace(HTML_ENTITY, htmlEntity)
     101  ), withCurlyBraces);
     102}
     103
     104function wrapWithCurlyBraces(rawText) {
     105  if (!containsLineTerminators(rawText)) {
     106    return `{${JSON.stringify(rawText)}}`;
     107  }
     108
     109  return rawText.split('\n').map((line) => {
     110    if (line.trim() === '') {
     111      return line;
     112    }
     113    const firstCharIndex = line.search(/[^\s]/);
     114    const leftWhitespace = line.slice(0, firstCharIndex);
     115    const text = line.slice(firstCharIndex);
     116
     117    if (containsHTMLEntity(line)) {
     118      return `${leftWhitespace}${wrapNonHTMLEntities(text)}`;
     119    }
     120    return `${leftWhitespace}{${JSON.stringify(text)}}`;
     121  }).join('\n');
     122}
     123
     124function isWhiteSpaceLiteral(node) {
     125  return node.type && node.type === 'Literal' && node.value && jsxUtil.isWhiteSpaces(node.value);
     126}
     127
     128function isStringWithTrailingWhiteSpaces(value) {
     129  return /^\s|\s$/.test(value);
     130}
     131
     132function isLiteralWithTrailingWhiteSpaces(node) {
     133  return node.type && node.type === 'Literal' && node.value && isStringWithTrailingWhiteSpaces(node.value);
     134}
    33135
    34136// ------------------------------------------------------------------------------
    … …  
    75177
    76178  create(context) {
    77     const HTML_ENTITY_REGEX = () => /&[A-Za-z\d#]+;/g;
    78179    const ruleOptions = context.options[0];
    79180    const userConfig = typeof ruleOptions === 'string'
    80181      ? { props: ruleOptions, children: ruleOptions, propElementValues: OPTION_IGNORE }
    81182      : Object.assign({}, DEFAULT_CONFIG, ruleOptions);
    82 
    83     function containsLineTerminators(rawStringValue) {
    84       return /[\n\r\u2028\u2029]/.test(rawStringValue);
    85     }
    86 
    87     function containsBackslash(rawStringValue) {
    88       return arrayIncludes(rawStringValue, '\\');
    89     }
    90 
    91     function containsHTMLEntity(rawStringValue) {
    92       return HTML_ENTITY_REGEX().test(rawStringValue);
    93     }
    94 
    95     function containsOnlyHtmlEntities(rawStringValue) {
    96       return rawStringValue.replace(HTML_ENTITY_REGEX(), '').trim() === '';
    97     }
    98 
    99     function containsDisallowedJSXTextChars(rawStringValue) {
    100       return /[{<>}]/.test(rawStringValue);
    101     }
    102 
    103     function containsQuoteCharacters(value) {
    104       return /['"]/.test(value);
    105     }
    106 
    107     function containsMultilineComment(value) {
    108       return /\/\*/.test(value);
    109     }
    110 
    111     function escapeDoubleQuotes(rawStringValue) {
    112       return rawStringValue.replace(/\\"/g, '"').replace(/"/g, '\\"');
    113     }
    114 
    115     function escapeBackslashes(rawStringValue) {
    116       return rawStringValue.replace(/\\/g, '\\\\');
    117     }
    118 
    119     function needToEscapeCharacterForJSX(raw, node) {
    120       return (
    121         containsBackslash(raw)
    122         || containsHTMLEntity(raw)
    123         || (node.parent.type !== 'JSXAttribute' && containsDisallowedJSXTextChars(raw))
    124       );
    125     }
    126 
    127     function containsWhitespaceExpression(child) {
    128       if (child.type === 'JSXExpressionContainer') {
    129         const value = child.expression.value;
    130         return value ? jsxUtil.isWhiteSpaces(value) : false;
    131       }
    132       return false;
    133     }
    134 
    135     function isLineBreak(text) {
    136       return containsLineTerminators(text) && text.trim() === '';
    137     }
    138 
    139     function wrapNonHTMLEntities(text) {
    140       const HTML_ENTITY = '<HTML_ENTITY>';
    141       const withCurlyBraces = text.split(HTML_ENTITY_REGEX()).map((word) => (
    142         word === '' ? '' : `{${JSON.stringify(word)}}`
    143       )).join(HTML_ENTITY);
    144 
    145       const htmlEntities = text.match(HTML_ENTITY_REGEX());
    146       return htmlEntities.reduce((acc, htmlEntity) => (
    147         acc.replace(HTML_ENTITY, htmlEntity)
    148       ), withCurlyBraces);
    149     }
    150 
    151     function wrapWithCurlyBraces(rawText) {
    152       if (!containsLineTerminators(rawText)) {
    153         return `{${JSON.stringify(rawText)}}`;
    154       }
    155 
    156       return rawText.split('\n').map((line) => {
    157         if (line.trim() === '') {
    158           return line;
    159         }
    160         const firstCharIndex = line.search(/[^\s]/);
    161         const leftWhitespace = line.slice(0, firstCharIndex);
    162         const text = line.slice(firstCharIndex);
    163 
    164         if (containsHTMLEntity(line)) {
    165           return `${leftWhitespace}${wrapNonHTMLEntities(text)}`;
    166         }
    167         return `${leftWhitespace}{${JSON.stringify(text)}}`;
    168       }).join('\n');
    169     }
    170183
    171184    /**
    … …  
    187200
    188201            if (parentType === 'JSXAttribute') {
    189               textToReplace = `"${expressionType === 'TemplateLiteral'
    190                 ? expression.quasis[0].value.raw
    191                 : expression.raw.slice(1, -1)
    192               }"`;
     202              if (expressionType !== 'TemplateLiteral' && /["]/.test(expression.raw.slice(1, -1))) {
     203                textToReplace = expression.raw;
     204              } else {
     205                textToReplace = `"${expressionType === 'TemplateLiteral'
     206                  ? expression.quasis[0].value.raw
     207                  : expression.raw.slice(1, -1)
     208                }"`;
     209              }
    193210            } else if (jsxUtil.isJSX(expression)) {
    194211              textToReplace = getText(context, expression);
    … …  
    234251    }
    235252
    236     function isWhiteSpaceLiteral(node) {
    237       return node.type && node.type === 'Literal' && node.value && jsxUtil.isWhiteSpaces(node.value);
    238     }
    239 
    240     function isStringWithTrailingWhiteSpaces(value) {
    241       return /^\s|\s$/.test(value);
    242     }
    243 
    244     function isLiteralWithTrailingWhiteSpaces(node) {
    245       return node.type && node.type === 'Literal' && node.value && isStringWithTrailingWhiteSpaces(node.value);
    246     }
    247 
    248253    // Bail out if there is any character that needs to be escaped in JSX
    249254    // because escaping decreases readability and the original code may be more
    … …  
    269274          && !needToEscapeCharacterForJSX(expression.raw, JSXExpressionNode) && (
    270275          jsxUtil.isJSX(JSXExpressionNode.parent)
    271           || !containsQuoteCharacters(expression.value)
     276          || (!containsQuoteCharacters(expression.value) || typeof expression.value === 'string')
    272277        )
    273278      ) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-curly-spacing.js

    rd565449 r0c6b92a  
    3636};
    3737
     38/** @type {import('eslint').Rule.RuleModule} */
    3839module.exports = {
    3940  meta: {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-equals-spacing.js

    rd565449 r0c6b92a  
    2121};
    2222
     23/** @type {import('eslint').Rule.RuleModule} */
    2324module.exports = {
    2425  meta: {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-first-prop-new-line.js

    rd565449 r0c6b92a  
    88const docsUrl = require('../util/docsUrl');
    99const report = require('../util/report');
     10const propsUtil = require('../util/props');
    1011
    1112// ------------------------------------------------------------------------------
    … …  
    5657                node: decl,
    5758                fix(fixer) {
    58                   return fixer.replaceTextRange([(node.typeParameters || node.name).range[1], decl.range[0]], '\n');
     59                  const nodeTypeArguments = propsUtil.getTypeArguments(node);
     60                  return fixer.replaceTextRange([(nodeTypeArguments || node.name).range[1], decl.range[0]], '\n');
    5961                },
    6062              });

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-fragments.js

    rd565449 r0c6b92a  
    2323
    2424const messages = {
    25   fragmentsNotSupported: 'Fragments are only supported starting from React v16.2. '
    26     + 'Please disable the `react/jsx-fragments` rule in `eslint` settings or upgrade your version of React.',
     25  fragmentsNotSupported: 'Fragments are only supported starting from React v16.2. Please disable the `react/jsx-fragments` rule in `eslint` settings or upgrade your version of React.',
    2726  preferPragma: 'Prefer {{react}}.{{fragment}} over fragment shorthand',
    2827  preferFragment: 'Prefer fragment shorthand over {{react}}.{{fragment}}',
    2928};
    3029
     30/** @type {import('eslint').Rule.RuleModule} */
    3131module.exports = {
    3232  meta: {
    … …  
    171171        if (node.source && node.source.value === 'react') {
    172172          node.specifiers.forEach((spec) => {
    173             if (spec.imported && spec.imported.name === fragmentPragma) {
     173            if ('imported' in spec && spec.imported && spec.imported.name === fragmentPragma) {
    174174              if (spec.local) {
    175175                fragmentNames.add(spec.local.name);

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-indent-props.js

    rd565449 r0c6b92a  
    4646};
    4747
     48/** @type {import('eslint').Rule.RuleModule} */
    4849module.exports = {
    4950  meta: {
    … …  
    117118     * Reports a given indent violation and properly pluralizes the message
    118119     * @param {ASTNode} node Node violating the indent rule
    119      * @param {Number} needed Expected indentation character count
    120      * @param {Number} gotten Indentation character count in the actual node/code
     120     * @param {number} needed Expected indentation character count
     121     * @param {number} gotten Indentation character count in the actual node/code
    121122     */
    122123    function report(node, needed, gotten) {
    … …  
    142143     * Get node indent
    143144     * @param {ASTNode} node Node to examine
    144      * @return {Number} Indent
     145     * @return {number} Indent
    145146     */
    146147    function getNodeIndent(node) {
    … …  
    174175     * Check indent for nodes list
    175176     * @param {ASTNode[]} nodes list of node objects
    176      * @param {Number} indent needed indent
     177     * @param {number} indent needed indent
    177178     */
    178179    function checkNodesIndent(nodes, indent) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-indent.js

    rd565449 r0c6b92a  
    5151};
    5252
     53/** @type {import('eslint').Rule.RuleModule} */
    5354module.exports = {
    5455  meta: {
    … …  
    106107     * Responsible for fixing the indentation issue fix
    107108     * @param {ASTNode} node Node violating the indent rule
    108      * @param {Number} needed Expected indentation character count
     109     * @param {number} needed Expected indentation character count
    109110     * @returns {Function} function to be executed by the fixer
    110111     * @private
    … …  
    147148     * Reports a given indent violation and properly pluralizes the message
    148149     * @param {ASTNode} node Node violating the indent rule
    149      * @param {Number} needed Expected indentation character count
    150      * @param {Number} gotten Indentation character count in the actual node/code
     150     * @param {number} needed Expected indentation character count
     151     * @param {number} gotten Indentation character count in the actual node/code
    151152     * @param {Object} [loc] Error line and column location
    152153     */
    … …  
    169170     * Get node indent
    170171     * @param {ASTNode} node Node to examine
    171      * @param {Boolean} [byLastLine] get indent of node's last line
    172      * @param {Boolean} [excludeCommas] skip comma on start of line
    173      * @return {Number} Indent
     172     * @param {boolean} [byLastLine] get indent of node's last line
     173     * @param {boolean} [excludeCommas] skip comma on start of line
     174     * @return {number} Indent
    174175     */
    175176    function getNodeIndent(node, byLastLine, excludeCommas) {
    … …  
    198199     * Check if the node is the right member of a logical expression
    199200     * @param {ASTNode} node The node to check
    200      * @return {Boolean} true if its the case, false if not
     201     * @return {boolean} true if its the case, false if not
    201202     */
    202203    function isRightInLogicalExp(node) {
    … …  
    213214     * Check if the node is the alternate member of a conditional expression
    214215     * @param {ASTNode} node The node to check
    215      * @return {Boolean} true if its the case, false if not
     216     * @return {boolean} true if its the case, false if not
    216217     */
    217218    function isAlternateInConditionalExp(node) {
    … …  
    228229     * Check if the node is within a DoExpression block but not the first expression (which need to be indented)
    229230     * @param {ASTNode} node The node to check
    230      * @return {Boolean} true if its the case, false if not
     231     * @return {boolean} true if its the case, false if not
    231232     */
    232233    function isSecondOrSubsequentExpWithinDoExp(node) {
    … …  
    299300     * Check indent for nodes list
    300301     * @param {ASTNode} node The node to check
    301      * @param {Number} indent needed indent
    302      * @param {Boolean} [excludeCommas] skip comma on start of line
     302     * @param {number} indent needed indent
     303     * @param {boolean} [excludeCommas] skip comma on start of line
    303304     */
    304305    function checkNodesIndent(node, indent, excludeCommas) {
    … …  
    319320     * Check indent for Literal Node or JSXText Node
    320321     * @param {ASTNode} node The node to check
    321      * @param {Number} indent needed indent
     322     * @param {number} indent needed indent
    322323     */
    323324    function checkLiteralNodeIndent(node, indent) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-max-depth.js

    rd565449 r0c6b92a  
    9292      function find(refs, prevRefs) {
    9393        for (let i = refs.length - 1; i >= 0; i--) {
    94           if (has(refs[i], 'writeExpr')) {
     94          if (typeof refs[i].writeExpr !== 'undefined') {
    9595            const writeExpr = refs[i].writeExpr;
    9696

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-no-bind.js

    rd565449 r0c6b92a  
    1010const propName = require('jsx-ast-utils/propName');
    1111const docsUrl = require('../util/docsUrl');
     12const astUtil = require('../util/ast');
    1213const jsxUtil = require('../util/jsx');
    1314const report = require('../util/report');
    … …  
    2526};
    2627
     28/** @type {import('eslint').Rule.RuleModule} */
    2729module.exports = {
    2830  meta: {
    … …  
    8486
    8587    function getNodeViolationType(node) {
    86       const nodeType = node.type;
    8788      if (
    8889        !configuration.allowBind
    89         && nodeType === 'CallExpression'
     90        && astUtil.isCallExpression(node)
    9091        && node.callee.type === 'MemberExpression'
    9192        && node.callee.property.type === 'Identifier'
    … …  
    9495        return 'bindCall';
    9596      }
    96       if (nodeType === 'ConditionalExpression') {
     97      if (node.type === 'ConditionalExpression') {
    9798        return getNodeViolationType(node.test)
    9899               || getNodeViolationType(node.consequent)
    99100               || getNodeViolationType(node.alternate);
    100101      }
    101       if (!configuration.allowArrowFunctions && nodeType === 'ArrowFunctionExpression') {
     102      if (!configuration.allowArrowFunctions && node.type === 'ArrowFunctionExpression') {
    102103        return 'arrowFunc';
    103104      }
    104105      if (
    105106        !configuration.allowFunctions
    106         && (nodeType === 'FunctionExpression' || nodeType === 'FunctionDeclaration')
     107        && (node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration')
    107108      ) {
    108109        return 'func';
    109110      }
    110       if (!configuration.allowBind && nodeType === 'BindExpression') {
     111      if (!configuration.allowBind && node.type === 'BindExpression') {
    111112        return 'bindExpression';
    112113      }
    … …  
    117118    /**
    118119     * @param {string | number} violationType
    119      * @param {any} variableName
     120     * @param {unknown} variableName
    120121     * @param {string | number} blockStart
    121122     */
    … …  
    176177          blockAncestors.length > 0
    177178          && variableViolationType
     179          && 'kind' in node.parent
    178180          && node.parent.kind === 'const' // only support const right now
    179181        ) {
    180           addVariableNameToSet(
    181             variableViolationType, node.id.name, blockAncestors[0].range[0]
    182           );
     182          addVariableNameToSet(variableViolationType, 'name' in node.id ? node.id.name : undefined, blockAncestors[0].range[0]);
    183183        }
    184184      },

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-no-leaked-render.js

    rd565449 r0c6b92a  
    110110}
    111111
    112 /**
    113  * @type {import('eslint').Rule.RuleModule}
    114  */
    115112/** @type {import('eslint').Rule.RuleModule} */
    116113module.exports = {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-no-literals.js

    rd565449 r0c6b92a  
    99const iterFrom = require('es-iterator-helpers/Iterator.from');
    1010const map = require('es-iterator-helpers/Iterator.prototype.map');
     11const some = require('es-iterator-helpers/Iterator.prototype.some');
     12const flatMap = require('es-iterator-helpers/Iterator.prototype.flatMap');
     13const fromEntries = require('object.fromentries');
     14const entries = require('object.entries');
    1115
    1216const docsUrl = require('../util/docsUrl');
    … …  
    1822// ------------------------------------------------------------------------------
    1923
    20 function trimIfString(val) {
    21   return typeof val === 'string' ? val.trim() : val;
     24/**
     25 * @param {unknown} value
     26 * @returns {string | unknown}
     27 */
     28function trimIfString(value) {
     29  return typeof value === 'string' ? value.trim() : value;
    2230}
     31
     32const reOverridableElement = /^[A-Z][\w.]*$/;
     33const reIsWhiteSpace = /^[\s]+$/;
     34const jsxElementTypes = new Set(['JSXElement', 'JSXFragment']);
     35const standardJSXNodeParentTypes = new Set(['JSXAttribute', 'JSXElement', 'JSXExpressionContainer', 'JSXFragment']);
    2336
    2437const messages = {
    2538  invalidPropValue: 'Invalid prop value: "{{text}}"',
     39  invalidPropValueInElement: 'Invalid prop value: "{{text}}" in {{element}}',
    2640  noStringsInAttributes: 'Strings not allowed in attributes: "{{text}}"',
     41  noStringsInAttributesInElement: 'Strings not allowed in attributes: "{{text}}" in {{element}}',
    2742  noStringsInJSX: 'Strings not allowed in JSX files: "{{text}}"',
     43  noStringsInJSXInElement: 'Strings not allowed in JSX files: "{{text}}" in {{element}}',
    2844  literalNotInJSXExpression: 'Missing JSX expression container around literal string: "{{text}}"',
     45  literalNotInJSXExpressionInElement: 'Missing JSX expression container around literal string: "{{text}}" in {{element}}',
    2946};
    3047
    31 /** @type {import('eslint').Rule.RuleModule} */
     48/** @type {Exclude<import('eslint').Rule.RuleModule['meta']['schema'], unknown[]>['properties']} */
     49const commonPropertiesSchema = {
     50  noStrings: {
     51    type: 'boolean',
     52  },
     53  allowedStrings: {
     54    type: 'array',
     55    uniqueItems: true,
     56    items: {
     57      type: 'string',
     58    },
     59  },
     60  ignoreProps: {
     61    type: 'boolean',
     62  },
     63  noAttributeStrings: {
     64    type: 'boolean',
     65  },
     66};
     67
     68/**
     69 * @typedef RawElementConfigProperties
     70 * @property {boolean} [noStrings]
     71 * @property {string[]} [allowedStrings]
     72 * @property {boolean} [ignoreProps]
     73 * @property {boolean} [noAttributeStrings]
     74 *
     75 * @typedef RawOverrideConfigProperties
     76 * @property {boolean} [allowElement]
     77 * @property {boolean} [applyToNestedElements=true]
     78 *
     79 * @typedef {RawElementConfigProperties} RawElementConfig
     80 * @typedef {RawElementConfigProperties & RawElementConfigProperties} RawOverrideConfig
     81 *
     82 * @typedef RawElementOverrides
     83 * @property {Record<string, RawOverrideConfig>} [elementOverrides]
     84 *
     85 * @typedef {RawElementConfig & RawElementOverrides} RawConfig
     86 *
     87 * ----------------------------------------------------------------------
     88 *
     89 * @typedef ElementConfigType
     90 * @property {'element'} type
     91 *
     92 * @typedef ElementConfigProperties
     93 * @property {boolean} noStrings
     94 * @property {Set<string>} allowedStrings
     95 * @property {boolean} ignoreProps
     96 * @property {boolean} noAttributeStrings
     97 *
     98 * @typedef OverrideConfigProperties
     99 * @property {'override'} type
     100 * @property {string} name
     101 * @property {boolean} allowElement
     102 * @property {boolean} applyToNestedElements
     103 *
     104 * @typedef {ElementConfigType & ElementConfigProperties} ElementConfig
     105 * @typedef {OverrideConfigProperties & ElementConfigProperties} OverrideConfig
     106 *
     107 * @typedef ElementOverrides
     108 * @property {Record<string, OverrideConfig>} elementOverrides
     109 *
     110 * @typedef {ElementConfig & ElementOverrides} Config
     111 * @typedef {Config | OverrideConfig} ResolvedConfig
     112 */
     113
     114/**
     115 * Normalizes the element portion of the config
     116 * @param {RawConfig} config
     117 * @returns {ElementConfig}
     118 */
     119function normalizeElementConfig(config) {
     120  return {
     121    type: 'element',
     122    noStrings: !!config.noStrings,
     123    allowedStrings: config.allowedStrings
     124      ? new Set(map(iterFrom(config.allowedStrings), trimIfString))
     125      : new Set(),
     126    ignoreProps: !!config.ignoreProps,
     127    noAttributeStrings: !!config.noAttributeStrings,
     128  };
     129}
     130
     131/**
     132 * Normalizes the config and applies default values to all config options
     133 * @param {RawConfig} config
     134 * @returns {Config}
     135 */
     136function normalizeConfig(config) {
     137  /** @type {Config} */
     138  const normalizedConfig = Object.assign(normalizeElementConfig(config), {
     139    elementOverrides: {},
     140  });
     141
     142  if (config.elementOverrides) {
     143    normalizedConfig.elementOverrides = fromEntries(
     144      flatMap(
     145        iterFrom(entries(config.elementOverrides)),
     146        (entry) => {
     147          const elementName = entry[0];
     148          const rawElementConfig = entry[1];
     149
     150          if (!reOverridableElement.test(elementName)) {
     151            return [];
     152          }
     153
     154          return [[
     155            elementName,
     156            Object.assign(normalizeElementConfig(rawElementConfig), {
     157              type: 'override',
     158              name: elementName,
     159              allowElement: !!rawElementConfig.allowElement,
     160              applyToNestedElements: typeof rawElementConfig.applyToNestedElements === 'undefined' || !!rawElementConfig.applyToNestedElements,
     161            }),
     162          ]];
     163        }
     164      )
     165    );
     166  }
     167
     168  return normalizedConfig;
     169}
     170
     171const elementOverrides = {
     172  type: 'object',
     173  patternProperties: {
     174    [reOverridableElement.source]: {
     175      type: 'object',
     176      properties: Object.assign(
     177        { applyToNestedElements: { type: 'boolean' } },
     178        commonPropertiesSchema
     179      ),
     180
     181    },
     182  },
     183};
     184
    32185module.exports = {
    33   meta: {
     186  meta: /** @type {import('eslint').Rule.RuleModule["meta"]} */ ({
    34187    docs: {
    35188      description: 'Disallow usage of string literals in JSX',
    … …  
    43196    schema: [{
    44197      type: 'object',
    45       properties: {
    46         noStrings: {
    47           type: 'boolean',
    48         },
    49         allowedStrings: {
    50           type: 'array',
    51           uniqueItems: true,
    52           items: {
    53             type: 'string',
    54           },
    55         },
    56         ignoreProps: {
    57           type: 'boolean',
    58         },
    59         noAttributeStrings: {
    60           type: 'boolean',
    61         },
    62       },
     198      properties: Object.assign(
     199        { elementOverrides },
     200        commonPropertiesSchema
     201      ),
    63202      additionalProperties: false,
    64203    }],
    65   },
     204  }),
    66205
    67206  create(context) {
    68     const defaults = {
    69       noStrings: false,
    70       allowedStrings: [],
    71       ignoreProps: false,
    72       noAttributeStrings: false,
    73     };
    74     const config = Object.assign({}, defaults, context.options[0] || {});
    75     config.allowedStrings = new Set(map(iterFrom(config.allowedStrings), trimIfString));
    76 
    77     function defaultMessageId() {
    78       const ancestorIsJSXElement = arguments.length >= 1 && arguments[0];
    79       if (config.noAttributeStrings && !ancestorIsJSXElement) {
    80         return 'noStringsInAttributes';
    81       }
    82       if (config.noStrings) {
    83         return 'noStringsInJSX';
    84       }
    85       return 'literalNotInJSXExpression';
    86     }
    87 
     207    /** @type {RawConfig} */
     208    const rawConfig = (context.options.length && context.options[0]) || {};
     209    const config = normalizeConfig(rawConfig);
     210
     211    const hasElementOverrides = Object.keys(config.elementOverrides).length > 0;
     212
     213    /** @type {Map<string, string>} */
     214    const renamedImportMap = new Map();
     215
     216    /**
     217     * Determines if the given expression is a require statement. Supports
     218     * nested MemberExpresions. ie `require('foo').nested.property`
     219     * @param {ASTNode} node
     220     * @returns {boolean}
     221     */
     222    function isRequireStatement(node) {
     223      if (node.type === 'CallExpression') {
     224        if (node.callee.type === 'Identifier') {
     225          return node.callee.name === 'require';
     226        }
     227      }
     228      if (node.type === 'MemberExpression') {
     229        return isRequireStatement(node.object);
     230      }
     231
     232      return false;
     233    }
     234
     235    /** @typedef {{ name: string, compoundName?: string }} ElementNameFragment */
     236
     237    /**
     238     * Gets the name of the given JSX element. Supports nested
     239     * JSXMemeberExpressions. ie `<Namesapce.Component.SubComponent />`
     240     * @param {ASTNode} node
     241     * @returns {ElementNameFragment | undefined}
     242     */
     243    function getJSXElementName(node) {
     244      if (node.openingElement.name.type === 'JSXIdentifier') {
     245        const name = node.openingElement.name.name;
     246        return {
     247          name: renamedImportMap.get(name) || name,
     248          compoundName: undefined,
     249        };
     250      }
     251
     252      /** @type {string[]} */
     253      const nameFragments = [];
     254
     255      if (node.openingElement.name.type === 'JSXMemberExpression') {
     256        /** @type {ASTNode} */
     257        let current = node.openingElement.name;
     258        while (current.type === 'JSXMemberExpression') {
     259          if (current.property.type === 'JSXIdentifier') {
     260            nameFragments.unshift(current.property.name);
     261          }
     262
     263          current = current.object;
     264        }
     265
     266        if (current.type === 'JSXIdentifier') {
     267          nameFragments.unshift(current.name);
     268
     269          const rootFragment = nameFragments[0];
     270          if (rootFragment) {
     271            const rootFragmentRenamed = renamedImportMap.get(rootFragment);
     272            if (rootFragmentRenamed) {
     273              nameFragments[0] = rootFragmentRenamed;
     274            }
     275          }
     276
     277          const nameFragment = nameFragments[nameFragments.length - 1];
     278          if (nameFragment) {
     279            return {
     280              name: nameFragment,
     281              compoundName: nameFragments.join('.'),
     282            };
     283          }
     284        }
     285      }
     286    }
     287
     288    /**
     289     * Gets all JSXElement ancestor nodes for the given node
     290     * @param {ASTNode} node
     291     * @returns {ASTNode[]}
     292     */
     293    function getJSXElementAncestors(node) {
     294      /** @type {ASTNode[]} */
     295      const ancestors = [];
     296
     297      let current = node;
     298      while (current) {
     299        if (current.type === 'JSXElement') {
     300          ancestors.push(current);
     301        }
     302
     303        current = current.parent;
     304      }
     305
     306      return ancestors;
     307    }
     308
     309    /**
     310     * @param {ASTNode} node
     311     * @returns {ASTNode}
     312     */
    88313    function getParentIgnoringBinaryExpressions(node) {
    89314      let current = node;
    … …  
    94319    }
    95320
    96     function getValidation(node) {
    97       const values = [trimIfString(node.raw), trimIfString(node.value)];
    98       if (values.some((value) => config.allowedStrings.has(value))) {
    99         return false;
    100       }
    101 
     321    /**
     322     * @param {ASTNode} node
     323     * @returns {{ parent: ASTNode, grandParent: ASTNode }}
     324     */
     325    function getParentAndGrandParent(node) {
    102326      const parent = getParentIgnoringBinaryExpressions(node);
    103 
    104       function isParentNodeStandard() {
    105         if (!/^[\s]+$/.test(node.value) && typeof node.value === 'string' && parent.type.includes('JSX')) {
    106           if (config.noAttributeStrings) {
    107             return parent.type === 'JSXAttribute' || parent.type === 'JSXElement';
    108           }
    109           if (!config.noAttributeStrings) {
    110             return parent.type !== 'JSXAttribute';
    111           }
    112         }
    113 
    114         return false;
    115       }
    116 
    117       const standard = isParentNodeStandard();
    118 
    119       if (config.noStrings) {
    120         return standard;
    121       }
    122       return standard && parent.type !== 'JSXExpressionContainer';
    123     }
    124 
    125     function getParentAndGrandParentType(node) {
    126       const parent = getParentIgnoringBinaryExpressions(node);
    127       const parentType = parent.type;
    128       const grandParentType = parent.parent.type;
    129 
    130327      return {
    131328        parent,
    132         parentType,
    133         grandParentType,
    134329        grandParent: parent.parent,
    135330      };
    136331    }
    137332
     333    /**
     334     * @param {ASTNode} node
     335     * @returns {boolean}
     336     */
    138337    function hasJSXElementParentOrGrandParent(node) {
    139       const parents = getParentAndGrandParentType(node);
    140       const parentType = parents.parentType;
    141       const grandParentType = parents.grandParentType;
    142 
    143       return parentType === 'JSXFragment' || parentType === 'JSXElement' || grandParentType === 'JSXElement';
    144     }
    145 
    146     function reportLiteralNode(node, messageId) {
    147       const ancestorIsJSXElement = hasJSXElementParentOrGrandParent(node);
    148       messageId = messageId || defaultMessageId(ancestorIsJSXElement);
    149 
     338      const ancestors = getParentAndGrandParent(node);
     339      return some(iterFrom([ancestors.parent, ancestors.grandParent]), (parent) => jsxElementTypes.has(parent.type));
     340    }
     341
     342    /**
     343     * Determines whether a given node's value and its immediate parent are
     344     * viable text nodes that can/should be reported on
     345     * @param {ASTNode} node
     346     * @param {ResolvedConfig} resolvedConfig
     347     * @returns {boolean}
     348     */
     349    function isViableTextNode(node, resolvedConfig) {
     350      const textValues = iterFrom([trimIfString(node.raw), trimIfString(node.value)]);
     351      if (some(textValues, (value) => resolvedConfig.allowedStrings.has(value))) {
     352        return false;
     353      }
     354
     355      const parent = getParentIgnoringBinaryExpressions(node);
     356
     357      let isStandardJSXNode = false;
     358      if (typeof node.value === 'string' && !reIsWhiteSpace.test(node.value) && standardJSXNodeParentTypes.has(parent.type)) {
     359        if (resolvedConfig.noAttributeStrings) {
     360          isStandardJSXNode = parent.type === 'JSXAttribute' || parent.type === 'JSXElement';
     361        } else {
     362          isStandardJSXNode = parent.type !== 'JSXAttribute';
     363        }
     364      }
     365
     366      if (resolvedConfig.noStrings) {
     367        return isStandardJSXNode;
     368      }
     369
     370      return isStandardJSXNode && parent.type !== 'JSXExpressionContainer';
     371    }
     372
     373    /**
     374     * Gets an override config for a given node. For any given node, we also
     375     * need to traverse the ancestor tree to determine if an ancestor's config
     376     * will also apply to the current node.
     377     * @param {ASTNode} node
     378     * @returns {OverrideConfig | undefined}
     379     */
     380    function getOverrideConfig(node) {
     381      if (!hasElementOverrides) {
     382        return;
     383      }
     384
     385      const allAncestorElements = getJSXElementAncestors(node);
     386      if (!allAncestorElements.length) {
     387        return;
     388      }
     389
     390      for (const ancestorElement of allAncestorElements) {
     391        const isClosestJSXAncestor = ancestorElement === allAncestorElements[0];
     392
     393        const ancestor = getJSXElementName(ancestorElement);
     394        if (ancestor) {
     395          if (ancestor.name) {
     396            const ancestorElements = config.elementOverrides[ancestor.name];
     397            const ancestorConfig = ancestor.compoundName
     398              ? config.elementOverrides[ancestor.compoundName] || ancestorElements
     399              : ancestorElements;
     400
     401            if (ancestorConfig) {
     402              if (isClosestJSXAncestor || ancestorConfig.applyToNestedElements) {
     403                return ancestorConfig;
     404              }
     405            }
     406          }
     407        }
     408      }
     409    }
     410
     411    /**
     412     * @param {ResolvedConfig} resolvedConfig
     413     * @returns {boolean}
     414     */
     415    function shouldAllowElement(resolvedConfig) {
     416      return resolvedConfig.type === 'override' && 'allowElement' in resolvedConfig && !!resolvedConfig.allowElement;
     417    }
     418
     419    /**
     420     * @param {boolean} ancestorIsJSXElement
     421     * @param {ResolvedConfig} resolvedConfig
     422     * @returns {string}
     423     */
     424    function defaultMessageId(ancestorIsJSXElement, resolvedConfig) {
     425      if (resolvedConfig.noAttributeStrings && !ancestorIsJSXElement) {
     426        return resolvedConfig.type === 'override' ? 'noStringsInAttributesInElement' : 'noStringsInAttributes';
     427      }
     428
     429      if (resolvedConfig.noStrings) {
     430        return resolvedConfig.type === 'override' ? 'noStringsInJSXInElement' : 'noStringsInJSX';
     431      }
     432
     433      return resolvedConfig.type === 'override' ? 'literalNotInJSXExpressionInElement' : 'literalNotInJSXExpression';
     434    }
     435
     436    /**
     437     * @param {ASTNode} node
     438     * @param {string} messageId
     439     * @param {ResolvedConfig} resolvedConfig
     440     */
     441    function reportLiteralNode(node, messageId, resolvedConfig) {
    150442      report(context, messages[messageId], messageId, {
    151443        node,
    152444        data: {
    153445          text: getText(context, node).trim(),
     446          element: resolvedConfig.type === 'override' && 'name' in resolvedConfig ? resolvedConfig.name : undefined,
    154447        },
    155448      });
    … …  
    160453    // --------------------------------------------------------------------------
    161454
    162     return {
     455    return Object.assign(hasElementOverrides ? {
     456      // Get renamed import local names mapped to their imported name
     457      ImportDeclaration(node) {
     458        node.specifiers
     459          .filter((s) => s.type === 'ImportSpecifier')
     460          .forEach((specifier) => {
     461            renamedImportMap.set(
     462              (specifier.local || specifier.imported).name,
     463              specifier.imported.name
     464            );
     465          });
     466      },
     467
     468      // Get renamed destructured local names mapped to their imported name
     469      VariableDeclaration(node) {
     470        node.declarations
     471          .filter((d) => (
     472            d.type === 'VariableDeclarator'
     473            && isRequireStatement(d.init)
     474            && d.id.type === 'ObjectPattern'
     475          ))
     476          .forEach((declaration) => {
     477            declaration.id.properties
     478              .filter((property) => (
     479                property.type === 'Property'
     480                && property.key.type === 'Identifier'
     481                && property.value.type === 'Identifier'
     482              ))
     483              .forEach((property) => {
     484                renamedImportMap.set(property.value.name, property.key.name);
     485              });
     486          });
     487      },
     488    } : false, {
    163489      Literal(node) {
    164         if (getValidation(node) && (hasJSXElementParentOrGrandParent(node) || !config.ignoreProps)) {
    165           reportLiteralNode(node);
     490        const resolvedConfig = getOverrideConfig(node) || config;
     491
     492        const hasJSXParentOrGrandParent = hasJSXElementParentOrGrandParent(node);
     493        if (hasJSXParentOrGrandParent && shouldAllowElement(resolvedConfig)) {
     494          return;
     495        }
     496
     497        if (isViableTextNode(node, resolvedConfig)) {
     498          if (hasJSXParentOrGrandParent || !config.ignoreProps) {
     499            reportLiteralNode(node, defaultMessageId(hasJSXParentOrGrandParent, resolvedConfig), resolvedConfig);
     500          }
    166501        }
    167502      },
    168503
    169504      JSXAttribute(node) {
    170         const isNodeValueString = node && node.value && node.value.type === 'Literal' && typeof node.value.value === 'string' && !config.allowedStrings.has(node.value.value);
    171 
    172         if (config.noStrings && !config.ignoreProps && isNodeValueString) {
    173           const messageId = 'invalidPropValue';
    174           reportLiteralNode(node, messageId);
     505        const isLiteralString = node.value && node.value.type === 'Literal'
     506          && typeof node.value.value === 'string';
     507        const isStringLiteral = node.value && node.value.type === 'StringLiteral';
     508
     509        if (isLiteralString || isStringLiteral) {
     510          const resolvedConfig = getOverrideConfig(node) || config;
     511
     512          if (
     513            resolvedConfig.noStrings
     514            && !resolvedConfig.ignoreProps
     515            && !resolvedConfig.allowedStrings.has(node.value.value)
     516          ) {
     517            const messageId = resolvedConfig.type === 'override' ? 'invalidPropValueInElement' : 'invalidPropValue';
     518            reportLiteralNode(node, messageId, resolvedConfig);
     519          }
    175520        }
    176521      },
    177522
    178523      JSXText(node) {
    179         if (getValidation(node)) {
    180           reportLiteralNode(node);
     524        const resolvedConfig = getOverrideConfig(node) || config;
     525
     526        if (shouldAllowElement(resolvedConfig)) {
     527          return;
     528        }
     529
     530        if (isViableTextNode(node, resolvedConfig)) {
     531          const hasJSXParendOrGrantParent = hasJSXElementParentOrGrandParent(node);
     532          reportLiteralNode(node, defaultMessageId(hasJSXParendOrGrantParent, resolvedConfig), resolvedConfig);
    181533        }
    182534      },
    183535
    184536      TemplateLiteral(node) {
    185         const parents = getParentAndGrandParentType(node);
    186         const parentType = parents.parentType;
    187         const grandParentType = parents.grandParentType;
    188         const isParentJSXExpressionCont = parentType === 'JSXExpressionContainer';
    189         const isParentJSXElement = parentType === 'JSXElement' || grandParentType === 'JSXElement';
    190 
    191         if (isParentJSXExpressionCont && config.noStrings && (isParentJSXElement || !config.ignoreProps)) {
    192           reportLiteralNode(node);
     537        const ancestors = getParentAndGrandParent(node);
     538        const isParentJSXExpressionCont = ancestors.parent.type === 'JSXExpressionContainer';
     539        const isParentJSXElement = ancestors.grandParent.type === 'JSXElement';
     540
     541        if (isParentJSXExpressionCont) {
     542          const resolvedConfig = getOverrideConfig(node) || config;
     543
     544          if (
     545            resolvedConfig.noStrings
     546            && (isParentJSXElement || !resolvedConfig.ignoreProps)
     547          ) {
     548            reportLiteralNode(node, defaultMessageId(isParentJSXElement, resolvedConfig), resolvedConfig);
     549          }
    193550        }
    194551      },
    195     };
     552    });
    196553  },
    197554};

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-no-target-blank.js

    rd565449 r0c6b92a  
    7171 * @param {ASTNode} value The AST node being checked.
    7272 * @param {ASTNode} targetValue The AST node being checked.
    73  * @returns {String | String[] | null} The string value, or null if not a string.
     73 * @returns {string | string[] | null} The string value, or null if not a string.
    7474 */
    7575function getStringFromValue(value, targetValue) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-no-useless-fragment.js

    rd565449 r0c6b92a  
    88
    99const pragmaUtil = require('../util/pragma');
     10const astUtil = require('../util/ast');
    1011const jsxUtil = require('../util/jsx');
    1112const docsUrl = require('../util/docsUrl');
    … …  
    7677  return node
    7778    && node.type === 'JSXExpressionContainer'
    78     && node.expression
    79     && node.expression.type === 'CallExpression';
     79    && astUtil.isCallExpression(node.expression);
    8080}
    8181

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-props-no-multi-spaces.js

    rd565449 r0c6b92a  
    99const eslintUtil = require('../util/eslint');
    1010const report = require('../util/report');
     11const propsUtil = require('../util/props');
    1112
    1213const getSourceCode = eslintUtil.getSourceCode;
    … …  
    104105
    105106    function containsGenericType(node) {
    106       const nodeTypeParams = node.typeParameters;
    107       if (typeof nodeTypeParams === 'undefined') {
     107      const nodeTypeArguments = propsUtil.getTypeArguments(node);
     108      if (typeof nodeTypeArguments === 'undefined') {
    108109        return false;
    109110      }
    110111
    111       return nodeTypeParams.type === 'TSTypeParameterInstantiation';
     112      return nodeTypeArguments.type === 'TSTypeParameterInstantiation';
    112113    }
    113114
    … …  
    115116      const name = node.name;
    116117      if (containsGenericType(node)) {
    117         const type = node.typeParameters;
     118        const nodeTypeArguments = propsUtil.getTypeArguments(node);
    118119
    119120        return Object.assign(
    … …  
    123124            range: [
    124125              name.range[0],
    125               type.range[1],
     126              nodeTypeArguments.range[1],
    126127            ],
    127128          }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-props-no-spreading.js

    rd565449 r0c6b92a  
    5959          },
    6060          custom: {
     61            enum: [OPTIONS.enforce, OPTIONS.ignore],
     62          },
     63          explicitSpread: {
    6164            enum: [OPTIONS.enforce, OPTIONS.ignore],
    6265          },

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-sort-default-props.js

    rd565449 r0c6b92a  
    2626};
    2727
     28/** @type {import('eslint').Rule.RuleModule} */
    2829module.exports = {
    2930  meta: {
    … …  
    5859     * Get properties name
    5960     * @param {Object} node - Property.
    60      * @returns {String} Property name.
     61     * @returns {string} Property name.
    6162     */
    6263    function getPropertyName(node) {
    … …  
    7980     * Checks if the Identifier node passed in looks like a defaultProps declaration.
    8081     * @param   {ASTNode}  node The node to check. Must be an Identifier node.
    81      * @returns {Boolean}       `true` if the node is a defaultProps declaration, `false` if not
     82     * @returns {boolean}       `true` if the node is a defaultProps declaration, `false` if not
    8283     */
    8384    function isDefaultPropsDeclaration(node) {
    … …  
    179180        }
    180181
    181         checkNode(node.parent.right);
     182        checkNode('right' in node.parent && node.parent.right);
    182183      },
    183184

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-sort-props.js

    rd565449 r0c6b92a  
    1313const jsxUtil = require('../util/jsx');
    1414const report = require('../util/report');
     15const propTypesSortUtil = require('../util/propTypesSort');
    1516const eslintUtil = require('../util/eslint');
    1617
    … …  
    2122// Rule Definition
    2223// ------------------------------------------------------------------------------
    23 
    24 function isCallbackPropName(name) {
    25   return /^on[A-Z]/.test(name);
    26 }
    2724
    2825function isMultilineProp(node) {
    … …  
    8683
    8784  if (options.callbacksLast) {
    88     const aIsCallback = isCallbackPropName(aProp);
    89     const bIsCallback = isCallbackPropName(bProp);
     85    const aIsCallback = propTypesSortUtil.isCallbackPropName(aProp);
     86    const bIsCallback = propTypesSortUtil.isCallbackPropName(bProp);
    9087    if (aIsCallback && !bIsCallback) {
    9188      return 1;
    … …  
    280277 * Checks if the `reservedFirst` option is valid
    281278 * @param {Object} context The context of the rule
    282  * @param {Boolean|Array<String>} reservedFirst The `reservedFirst` option
    283  * @return {Function|undefined} If an error is detected, a function to generate the error message, otherwise, `undefined`
     279 * @param {boolean | string[]} reservedFirst The `reservedFirst` option
     280 * @return {Function | undefined} If an error is detected, a function to generate the error message, otherwise, `undefined`
    284281 */
    285282// eslint-disable-next-line consistent-return
    … …  
    426423          const previousValue = memo.value;
    427424          const currentValue = decl.value;
    428           const previousIsCallback = isCallbackPropName(previousPropName);
    429           const currentIsCallback = isCallbackPropName(currentPropName);
     425          const previousIsCallback = propTypesSortUtil.isCallbackPropName(previousPropName);
     426          const currentIsCallback = propTypesSortUtil.isCallbackPropName(currentPropName);
    430427
    431428          if (ignoreCase) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/jsx-space-before-closing.js

    rd565449 r0c6b92a  
    2424};
    2525
     26/** @type {import('eslint').Rule.RuleModule} */
    2627module.exports = {
    2728  meta: {
    … …  
    5960
    6061        const leftToken = getTokenBeforeClosingBracket(node);
    61         const closingSlash = sourceCode.getTokenAfter(leftToken);
     62        const closingSlash = /** @type {import("eslint").AST.Token} */ (sourceCode.getTokenAfter(leftToken));
    6263
    6364        if (leftToken.loc.end.line !== closingSlash.loc.start.line) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-access-state-in-setstate.js

    rd565449 r0c6b92a  
    77
    88const docsUrl = require('../util/docsUrl');
     9const astUtil = require('../util/ast');
    910const componentUtil = require('../util/componentUtil');
    1011const report = require('../util/report');
    … …  
    1920};
    2021
     22/** @type {import('eslint').Rule.RuleModule} */
    2123module.exports = {
    2224  meta: {
    … …  
    3335  create(context) {
    3436    function isSetStateCall(node) {
    35       return node.type === 'CallExpression'
     37      return astUtil.isCallExpression(node)
    3638        && node.callee.property
    3739        && node.callee.property.name === 'setState'
    … …  
    7375        // method containing this.state to the methods array
    7476        methods.forEach((method) => {
    75           if (node.callee.name === method.methodName) {
     77          if ('name' in node.callee && node.callee.name === method.methodName) {
    7678            let current = node.parent;
    7779            while (current.type !== 'Program') {
    7880              if (current.type === 'MethodDefinition') {
    7981                methods.push({
    80                   methodName: current.key.name,
     82                  methodName: 'name' in current.key ? current.key.name : undefined,
    8183                  node: method.node,
    8284                });
    … …  
    9395        while (current.type !== 'Program') {
    9496          if (isFirstArgumentInSetStateCall(current, node)) {
    95             const methodName = node.callee.name;
     97            const methodName = 'name' in node.callee ? node.callee.name : undefined;
    9698            methods.forEach((method) => {
    9799              if (method.methodName === methodName) {
    … …  
    110112      MemberExpression(node) {
    111113        if (
    112           node.property.name === 'state'
     114          'name' in node.property
     115          && node.property.name === 'state'
    113116          && node.object.type === 'ThisExpression'
    114117          && isClassComponent(node)
    115118        ) {
     119          /** @type {import("eslint").Rule.Node} */
    116120          let current = node;
    117121          while (current.type !== 'Program') {
    … …  
    127131            if (current.type === 'MethodDefinition') {
    128132              methods.push({
    129                 methodName: current.key.name,
    130                 node,
    131               });
    132               break;
    133             } else if (current.type === 'FunctionExpression' && current.parent.key) {
     133                methodName: 'name' in current.key ? current.key.name : undefined,
     134                node,
     135              });
     136              break;
     137            } else if (
     138              current.type === 'FunctionExpression'
     139              && 'key' in current.parent
     140              && current.parent.key
     141            ) {
    134142              methods.push({
    135                 methodName: current.parent.key.name,
     143                methodName: 'name' in current.parent.key ? current.parent.key.name : undefined,
    136144                node,
    137145              });
    … …  
    144152                node,
    145153                scope: getScope(context, node),
    146                 variableName: current.id.name,
     154                variableName: 'name' in current.id ? current.id.name : undefined,
    147155              });
    148156              break;
    … …  
    156164      Identifier(node) {
    157165        // Checks if the identifier is a variable within an object
     166        /** @type {import("eslint").Rule.Node} */
    158167        let current = node;
    159168        while (current.parent.type === 'BinaryExpression') {
    … …  
    161170        }
    162171        if (
    163           current.parent.value === current
    164           || current.parent.object === current
     172          ('value' in current.parent && current.parent.value === current)
     173          || ('object' in current.parent && current.parent.object === current)
    165174        ) {
    166175          while (current.type !== 'Program') {
    … …  
    180189
    181190      ObjectPattern(node) {
    182         const isDerivedFromThis = node.parent.init && node.parent.init.type === 'ThisExpression';
     191        const isDerivedFromThis = 'init' in node.parent && node.parent.init && node.parent.init.type === 'ThisExpression';
    183192        node.properties.forEach((property) => {
    184           if (property && property.key && property.key.name === 'state' && isDerivedFromThis) {
     193          if (
     194            property
     195            && 'key' in property
     196            && property.key
     197            && 'name' in property.key
     198            && property.key.name === 'state'
     199            && isDerivedFromThis
     200          ) {
    185201            vars.push({
    186202              node: property.key,

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-adjacent-inline-elements.js

    rd565449 r0c6b92a  
    99const isCreateElement = require('../util/isCreateElement');
    1010const report = require('../util/report');
     11const astUtil = require('../util/ast');
    1112
    1213// ------------------------------------------------------------------------------
    … …  
    6364    return true;
    6465  }
    65   if (node.type === 'CallExpression' && inlineNames.indexOf(node.arguments[0].value) > -1) {
     66  if (astUtil.isCallExpression(node) && inlineNames.indexOf(node.arguments[0].value) > -1) {
    6667    return true;
    6768  }
    … …  
    7778};
    7879
     80/** @type {import('eslint').Rule.RuleModule} */
    7981module.exports = {
    8082  meta: {
    … …  
    118120          return;
    119121        }
    120         const children = node.arguments[2].elements;
     122        const children = 'elements' in node.arguments[2] ? node.arguments[2].elements : undefined;
    121123        validate(node, children);
    122124      },

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-array-index-key.js

    rd565449 r0c6b92a  
    190190      }
    191191
    192       if (node.type === 'CallExpression'
    193           && node.callee
    194           && node.callee.type === 'MemberExpression'
    195           && node.callee.object
    196           && isArrayIndex(node.callee.object)
    197           && node.callee.property
    198           && node.callee.property.type === 'Identifier'
    199           && node.callee.property.name === 'toString'
     192      if (
     193        astUtil.isCallExpression(node)
     194        && node.callee
     195        && node.callee.type === 'MemberExpression'
     196        && node.callee.object
     197        && isArrayIndex(node.callee.object)
     198        && node.callee.property
     199        && node.callee.property.type === 'Identifier'
     200        && node.callee.property.name === 'toString'
    200201      ) {
    201202        // key={bar.toString()}
    … …  
    206207      }
    207208
    208       if (node.type === 'CallExpression'
    209           && node.callee
    210           && node.callee.type === 'Identifier'
    211           && node.callee.name === 'String'
    212           && Array.isArray(node.arguments)
    213           && node.arguments.length > 0
    214           && isArrayIndex(node.arguments[0])
     209      if (
     210        astUtil.isCallExpression(node)
     211        && node.callee
     212        && node.callee.type === 'Identifier'
     213        && node.callee.name === 'String'
     214        && Array.isArray(node.arguments)
     215        && node.arguments.length > 0
     216        && isArrayIndex(node.arguments[0])
    215217      ) {
    216218        // key={String(bar)}

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-children-prop.js

    rd565449 r0c6b92a  
    1818 * @param {ASTNode} node - The AST node being checked.
    1919 * @param {Context} context - The AST node being checked.
    20  * @returns {Boolean} - True if node is a createElement call with a props
     20 * @returns {boolean} - True if node is a createElement call with a props
    2121 * object literal, False if not.
    2222*/
    … …  
    3838};
    3939
     40/** @type {import('eslint').Rule.RuleModule} */
    4041module.exports = {
    4142  meta: {
    … …  
    8788        }
    8889
    89         const props = node.arguments[1].properties;
    90         const childrenProp = props.find((prop) => prop.key && prop.key.name === 'children');
     90        const props = 'properties' in node.arguments[1] ? node.arguments[1].properties : undefined;
     91        const childrenProp = props.find((prop) => (
     92          'key' in prop
     93          && prop.key
     94          && 'name' in prop.key
     95          && prop.key.name === 'children'
     96        ));
    9197
    9298        if (childrenProp) {
    93           if (childrenProp.value && !isFunction(childrenProp.value)) {
     99          if ('value' in childrenProp && childrenProp.value && !isFunction(childrenProp.value)) {
    94100            report(context, messages.passChildrenAsArgs, 'passChildrenAsArgs', {
    95101              node,

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-danger-with-children.js

    rd565449 r0c6b92a  
    1818};
    1919
     20/** @type {import('eslint').Rule.RuleModule} */
    2021module.exports = {
    2122  meta: {
    … …  
    8687     * Checks to see if a node is a line break
    8788     * @param {ASTNode} node The AST node being checked
    88      * @returns {Boolean} True if node is a line break, false if not
     89     * @returns {boolean} True if node is a line break, false if not
    8990     */
    9091    function isLineBreak(node) {
    … …  
    120121          node.callee
    121122          && node.callee.type === 'MemberExpression'
     123          && 'name' in node.callee.property
    122124          && node.callee.property.name === 'createElement'
    123125          && node.arguments.length > 1

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-danger.js

    rd565449 r0c6b92a  
    3030/**
    3131 * Checks if a JSX attribute is dangerous.
    32  * @param {String} name - Name of the attribute to check.
     32 * @param {string} name - Name of the attribute to check.
    3333 * @returns {boolean} Whether or not the attribute is dangerous.
    3434 */

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-deprecated.js

    rd565449 r0c6b92a  
    116116};
    117117
     118/** @type {import('eslint').Rule.RuleModule} */
    118119module.exports = {
    119120  meta: {
    … …  
    227228          return;
    228229        }
    229         node.specifiers.filter(((s) => s.imported)).forEach((specifier) => {
    230           checkDeprecation(node, `${MODULES[node.source.value][0]}.${specifier.imported.name}`, specifier);
     230        node.specifiers.filter(((s) => 'imported' in s && s.imported)).forEach((specifier) => {
     231          // TODO, semver-major: remove `in` check as part of jsdoc->tsdoc migration
     232          checkDeprecation(node, 'imported' in specifier && `${MODULES[node.source.value][0]}.${specifier.imported.name}`, specifier);
    231233        });
    232234      },
    … …  
    234236      VariableDeclarator(node) {
    235237        const reactModuleName = getReactModuleName(node);
    236         const isRequire = node.init && node.init.callee && node.init.callee.name === 'require';
     238        const isRequire = node.init
     239          && 'callee' in node.init
     240          && node.init.callee
     241          && 'name' in node.init.callee
     242          && node.init.callee.name === 'require';
    237243        const isReactRequire = node.init
     244          && 'arguments' in node.init
    238245          && node.init.arguments
    239246          && node.init.arguments.length
    240           && typeof MODULES[node.init.arguments[0].value] !== 'undefined';
     247          && typeof MODULES['value' in node.init.arguments[0] ? node.init.arguments[0].value : undefined] !== 'undefined';
    241248        const isDestructuring = node.id && node.id.type === 'ObjectPattern';
    242249
    … …  
    247254          return;
    248255        }
    249         node.id.properties.filter((p) => p.type !== 'RestElement' && p.key).forEach((property) => {
    250           checkDeprecation(node, `${reactModuleName || pragma}.${property.key.name}`, property);
     256
     257        ('properties' in node.id ? node.id.properties : undefined).filter((p) => p.type !== 'RestElement' && p.key).forEach((property) => {
     258          checkDeprecation(
     259            node,
     260            'key' in property && 'name' in property.key && `${reactModuleName || pragma}.${property.key.name}`,
     261            property
     262          );
    251263        });
    252264      },

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-direct-mutation-state.js

    rd565449 r0c6b92a  
    3939     * Checks if the component is valid
    4040     * @param {Object} component The component to process
    41      * @returns {Boolean} True if the component is valid, false if not.
     41     * @returns {boolean} True if the component is valid, false if not.
    4242     */
    4343    function isValid(component) {
    44       return Boolean(component && !component.mutateSetState);
     44      return !!component && !component.mutateSetState;
    4545    }
    4646
    … …  
    7474     * Determine if we should currently ignore assignments in this component.
    7575     * @param {?Object} component The component to process
    76      * @returns {Boolean} True if we should skip assignment checks.
     76     * @returns {boolean} True if we should skip assignment checks.
    7777     */
    7878    function shouldIgnoreComponent(component) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-find-dom-node.js

    rd565449 r0c6b92a  
    1717};
    1818
     19/** @type {import('eslint').Rule.RuleModule} */
    1920module.exports = {
    2021  meta: {
    … …  
    3637        const callee = node.callee;
    3738
    38         const isfindDOMNode = (callee.name === 'findDOMNode')
    39           || (callee.property && callee.property.name === 'findDOMNode');
    40         if (!isfindDOMNode) {
     39        const isFindDOMNode = ('name' in callee && callee.name === 'findDOMNode') || (
     40          'property' in callee
     41          && callee.property
     42          && 'name' in callee.property
     43          && callee.property.name === 'findDOMNode'
     44        );
     45
     46        if (!isFindDOMNode) {
    4147          return;
    4248        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-invalid-html-attribute.js

    rd565449 r0c6b92a  
    290290
    291291  const singleAttributeParts = splitIntoRangedParts(node, /(\S+)/g);
    292   for (const singlePart of singleAttributeParts) {
     292  singleAttributeParts.forEach((singlePart) => {
    293293    const allowedTags = VALID_VALUES.get(attributeName).get(singlePart.value);
    294294    const reportingValue = singlePart.reportingValue;
    … …  
    330330      });
    331331    }
    332   }
     332  });
    333333
    334334  const allowedPairsForAttribute = VALID_PAIR_VALUES.get(attributeName);
    335335  if (allowedPairsForAttribute) {
    336336    const pairAttributeParts = splitIntoRangedParts(node, /(?=(\b\S+\s*\S+))/g);
    337     for (const pairPart of pairAttributeParts) {
    338       for (const allowedPair of allowedPairsForAttribute) {
    339         const pairing = allowedPair[0];
    340         const siblings = allowedPair[1];
     337    pairAttributeParts.forEach((pairPart) => {
     338      allowedPairsForAttribute.forEach((siblings, pairing) => {
    341339        const attributes = pairPart.reportingValue.split('\u0020');
    342340        const firstValue = attributes[0];
    … …  
    358356          }
    359357        }
    360       }
    361     }
     358      });
     359    });
    362360  }
    363361
    364362  const whitespaceParts = splitIntoRangedParts(node, /(\s+)/g);
    365   for (const whitespacePart of whitespaceParts) {
     363  whitespaceParts.forEach((whitespacePart) => {
    366364    const data = { attributeName };
    367365
    … …  
    387385      });
    388386    }
    389   }
     387  });
    390388}
    391389
    … …  
    580578
    581579    if (prop.value.type === 'ArrayExpression') {
    582       for (const value of prop.value.elements) {
     580      prop.value.elements.forEach((value) => {
    583581        checkPropValidValue(context, node, value, attribute);
    584       }
     582      });
    585583
    586584      // eslint-disable-next-line no-continue
    … …  
    592590}
    593591
     592/** @type {import('eslint').Rule.RuleModule} */
    594593module.exports = {
    595594  meta: {
    … …  
    641640
    642641        // ignore non-HTML elements
    643         if (!HTML_ELEMENTS.has(elemNameArg.value)) {
     642        if (typeof elemNameArg.value === 'string' && !HTML_ELEMENTS.has(elemNameArg.value)) {
    644643          return;
    645644        }
    … …  
    647646        const attributes = new Set(context.options[0] || DEFAULT_ATTRIBUTES);
    648647
    649         for (const attribute of attributes) {
     648        attributes.forEach((attribute) => {
    650649          checkCreateProps(context, node, attribute);
    651         }
     650        });
    652651      },
    653652    };

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-is-mounted.js

    rd565449 r0c6b92a  
    1818};
    1919
     20/** @type {import('eslint').Rule.RuleModule} */
    2021module.exports = {
    2122  meta: {
    … …  
    3940          return;
    4041        }
    41         if (callee.object.type !== 'ThisExpression' || callee.property.name !== 'isMounted') {
     42        if (
     43          callee.object.type !== 'ThisExpression'
     44          || !('name' in callee.property)
     45          || callee.property.name !== 'isMounted'
     46        ) {
    4247          return;
    4348        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-multi-comp.js

    rd565449 r0c6b92a  
    5151     * Checks if the component is ignored
    5252     * @param {Object} component The component being checked.
    53      * @returns {Boolean} True if the component is ignored, false if not.
     53     * @returns {boolean} True if the component is ignored, false if not.
    5454     */
    5555    function isIgnored(component) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-object-type-as-default-prop.js

    rd565449 r0c6b92a  
    1010const Components = require('../util/Components');
    1111const docsUrl = require('../util/docsUrl');
     12const astUtil = require('../util/ast');
    1213const report = require('../util/report');
    1314
    … …  
    5657      });
    5758    } else if (
    58       propDefaultValueType === 'CallExpression'
     59      astUtil.isCallExpression(propDefaultValue.right)
    5960      && propDefaultValue.right.callee.type === 'Identifier'
    6061      && propDefaultValue.right.callee.name === 'Symbol'

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-redundant-should-component-update.js

    rd565449 r0c6b92a  
    3737     * Checks for shouldComponentUpdate property
    3838     * @param {ASTNode} node The AST node being checked.
    39      * @returns {Boolean} Whether or not the property exists.
     39     * @returns {boolean} Whether or not the property exists.
    4040     */
    4141    function hasShouldComponentUpdate(node) {
    … …  
    5050     * Get name of node if available
    5151     * @param {ASTNode} node The AST node being checked.
    52      * @return {String} The name of the node
     52     * @return {string} The name of the node
    5353     */
    5454    function getNodeName(node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-render-return-value.js

    rd565449 r0c6b92a  
    1818};
    1919
     20/** @type {import('eslint').Rule.RuleModule} */
    2021module.exports = {
    2122  meta: {
    … …  
    5758          callee.object.type !== 'Identifier'
    5859          || !calleeObjectName.test(callee.object.name)
    59           || callee.property.name !== 'render'
     60          || (!('name' in callee.property) || callee.property.name !== 'render')
    6061        ) {
    6162          return;

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-set-state.js

    rd565449 r0c6b92a  
    3939     * Checks if the component is valid
    4040     * @param {Object} component The component to process
    41      * @returns {Boolean} True if the component is valid, false if not.
     41     * @returns {boolean} True if the component is valid, false if not.
    4242     */
    4343    function isValid(component) {
    44       return Boolean(component && !component.useSetState);
     44      return !!component && !component.useSetState;
    4545    }
    4646
    … …  
    5050     */
    5151    function reportSetStateUsages(component) {
    52       let setStateUsage;
    5352      for (let i = 0, j = component.setStateUsages.length; i < j; i++) {
    54         setStateUsage = component.setStateUsages[i];
     53        const setStateUsage = component.setStateUsages[i];
    5554        report(context, messages.noSetState, 'noSetState', {
    5655          node: setStateUsage,

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-string-refs.js

    rd565449 r0c6b92a  
    99const docsUrl = require('../util/docsUrl');
    1010const report = require('../util/report');
     11const testReactVersion = require('../util/version').testReactVersion;
    1112
    1213// ------------------------------------------------------------------------------
    … …  
    4344
    4445  create(context) {
     46    const checkRefsUsage = testReactVersion(context, '< 18.3.0'); // `this.refs` is writable in React 18.3.0 and later, see https://github.com/facebook/react/pull/28867
    4547    const detectTemplateLiterals = context.options[0] ? context.options[0].noTemplateLiterals : false;
    4648    /**
    4749     * Checks if we are using refs
    4850     * @param {ASTNode} node The AST node being checked.
    49      * @returns {Boolean} True if we are using refs, false if not.
     51     * @returns {boolean} True if we are using refs, false if not.
    5052     */
    5153    function isRefsUsage(node) {
    … …  
    6062     * Checks if we are using a ref attribute
    6163     * @param {ASTNode} node The AST node being checked.
    62      * @returns {Boolean} True if we are using a ref attribute, false if not.
     64     * @returns {boolean} True if we are using a ref attribute, false if not.
    6365     */
    6466    function isRefAttribute(node) {
    65       return !!(
    66         node.type === 'JSXAttribute'
    67         && node.name
    68         && node.name.name === 'ref'
    69       );
     67      return node.type === 'JSXAttribute'
     68        && !!node.name
     69        && node.name.name === 'ref';
    7070    }
    7171
    … …  
    7373     * Checks if a node contains a string value
    7474     * @param {ASTNode} node The AST node being checked.
    75      * @returns {Boolean} True if the node contains a string value, false if not.
     75     * @returns {boolean} True if the node contains a string value, false if not.
    7676     */
    7777    function containsStringLiteral(node) {
    78       return !!(
    79         node.value
     78      return !!node.value
    8079        && node.value.type === 'Literal'
    81         && typeof node.value.value === 'string'
    82       );
     80        && typeof node.value.value === 'string';
    8381    }
    8482
    … …  
    8684     * Checks if a node contains a string value within a jsx expression
    8785     * @param {ASTNode} node The AST node being checked.
    88      * @returns {Boolean} True if the node contains a string value within a jsx expression, false if not.
     86     * @returns {boolean} True if the node contains a string value within a jsx expression, false if not.
    8987     */
    9088    function containsStringExpressionContainer(node) {
    91       return !!(
    92         node.value
     89      return !!node.value
    9390        && node.value.type === 'JSXExpressionContainer'
    9491        && node.value.expression
    9592        && ((node.value.expression.type === 'Literal' && typeof node.value.expression.value === 'string')
    96         || (node.value.expression.type === 'TemplateLiteral' && detectTemplateLiterals))
    97       );
     93        || (node.value.expression.type === 'TemplateLiteral' && detectTemplateLiterals));
    9894    }
    9995
    10096    return {
    10197      MemberExpression(node) {
    102         if (isRefsUsage(node)) {
     98        if (checkRefsUsage && isRefsUsage(node)) {
    10399          report(context, messages.thisRefsDeprecated, 'thisRefsDeprecated', {
    104100            node,
    … …  
    106102        }
    107103      },
     104
    108105      JSXAttribute(node) {
    109106        if (

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-typos.js

    rd565449 r0c6b92a  
    88const Components = require('../util/Components');
    99const docsUrl = require('../util/docsUrl');
     10const astUtil = require('../util/ast');
    1011const componentUtil = require('../util/componentUtil');
    1112const report = require('../util/report');
    … …  
    110111        ) { // PropTypes.myProp
    111112          checkValidPropType(node.property);
    112         } else if (node.object.type === 'CallExpression') {
     113        } else if (astUtil.isCallExpression(node.object)) {
    113114          checkValidPropTypeQualifier(node.property);
    114115          checkValidCallExpression(node.object);
    115116        }
    116       } else if (node.type === 'CallExpression') {
     117      } else if (astUtil.isCallExpression(node)) {
    117118        checkValidCallExpression(node);
    118119      }
    … …  
    195196          if (node.specifiers.length >= 1) {
    196197            const propTypesSpecifier = node.specifiers.find((specifier) => (
    197               specifier.imported && specifier.imported.name === 'PropTypes'
     198              specifier.imported
     199              && specifier.imported.name === 'PropTypes'
    198200            ));
    199201            if (propTypesSpecifier) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unescaped-entities.js

    rd565449 r0c6b92a  
    1010const jsxUtil = require('../util/jsx');
    1111const report = require('../util/report');
     12const getMessageData = require('../util/message');
    1213
    1314// ------------------------------------------------------------------------------
    … …  
    3536  unescapedEntity: 'HTML entity, `{{entity}}` , must be escaped.',
    3637  unescapedEntityAlts: '`{{entity}}` can be escaped with {{alts}}.',
     38  replaceWithAlt: 'Replace with `{{alt}}`.',
    3739};
    3840
    … …  
    4042module.exports = {
    4143  meta: {
     44    hasSuggestions: true,
    4245    docs: {
    4346      description: 'Disallow unescaped HTML entities from appearing in markup',
    … …  
    118121                  alts: entities[j].alternatives.map((alt) => `\`${alt}\``).join(', '),
    119122                },
     123                suggest: entities[j].alternatives.map((alt) => Object.assign(
     124                  getMessageData('replaceWithAlt', messages.replaceWithAlt),
     125                  {
     126                    data: { alt },
     127                    fix(fixer) {
     128                      const lineToChange = i - node.loc.start.line;
     129
     130                      const newText = node.raw.split('\n').map((line, idx) => {
     131                        if (idx === lineToChange) {
     132                          return line.slice(0, index) + alt + line.slice(index + 1);
     133                        }
     134
     135                        return line;
     136                      }).join('\n');
     137
     138                      return fixer.replaceText(node, newText);
     139                    },
     140                  }
     141                )),
    120142              });
    121143            }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unknown-property.js

    rd565449 r0c6b92a  
    416416 * Note - these exclusions are not made by React core team, but `eslint-plugin-react` community.
    417417 *
    418  * @param {String} name - Attribute name to be normalized
    419  * @returns {String} Result
     418 * @param {string} name - Attribute name to be normalized
     419 * @returns {string} Result
    420420 */
    421421function normalizeAttributeCase(name) {
    … …  
    429429 * then the attribute is a valid data attribute.
    430430 *
    431  * @param {String} name - Attribute name to be tested
     431 * @param {string} name - Attribute name to be tested
    432432 * @returns {boolean} Result
    433433 */
    … …  
    439439 * Checks if an attribute name has at least one uppercase characters
    440440 *
    441  * @param {String} name
     441 * @param {string} name
    442442 * @returns {boolean} Result
    443443 */
    … …  
    450450 * of standard aria property names
    451451 *
    452  * @param {String} name - Attribute name to be tested
    453  * @returns {Boolean} Result
     452 * @param {string} name - Attribute name to be tested
     453 * @returns {boolean} Result
    454454 */
    455455
    … …  
    461461 * Extracts the tag name for the JSXAttribute
    462462 * @param {JSXAttribute} node - JSXAttribute being tested.
    463  * @returns {String|null} tag name
     463 * @returns {string | null} tag name
    464464 */
    465465function getTagName(node) {
    466   if (node && node.parent && node.parent.name && node.parent.name) {
     466  if (
     467    node
     468    && node.parent
     469    && node.parent.name
     470  ) {
    467471    return node.parent.name.name;
    468472  }
    … …  
    474478 * something like <Foo.bar />
    475479 * @param {JSXAttribute} node - JSXAttribute being tested.
    476  * @returns {Boolean} result
     480 * @returns {boolean} result
    477481 */
    478482function tagNameHasDot(node) {
    … …  
    486490/**
    487491 * Get the standard name of the attribute.
    488  * @param {String} name - Name of the attribute.
    489  * @param {String} context - eslint context
    490  * @returns {String | undefined} The standard name of the attribute, or undefined if no standard name was found.
     492 * @param {string} name - Name of the attribute.
     493 * @param {object} context - eslint context
     494 * @returns {string | undefined} The standard name of the attribute, or undefined if no standard name was found.
    491495 */
    492496function getStandardName(name, context) {
    … …  
    513517};
    514518
     519/** @type {import('eslint').Rule.RuleModule} */
    515520module.exports = {
    516521  meta: {
    … …  
    593598
    594599        // Some attributes are allowed on some tags only
    595         const allowedTags = has(ATTRIBUTE_TAGS_MAP, name) ? ATTRIBUTE_TAGS_MAP[/** @type {keyof ATTRIBUTE_TAGS_MAP} */ (name)] : null;
     600        const allowedTags = has(ATTRIBUTE_TAGS_MAP, name)
     601          ? ATTRIBUTE_TAGS_MAP[/** @type {keyof ATTRIBUTE_TAGS_MAP} */ (name)]
     602          : null;
    596603        if (tagName && allowedTags) {
    597604          // Scenario 1A: Allowed attribute found where not supposed to, report it

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unsafe.js

    rd565449 r0c6b92a  
    5858      UNSAFE_componentWillMount: {
    5959        newMethod: 'componentDidMount',
    60         details:
    61           'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
     60        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
    6261      },
    6362      UNSAFE_componentWillReceiveProps: {
    6463        newMethod: 'getDerivedStateFromProps',
    65         details:
    66           'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
     64        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
    6765      },
    6866      UNSAFE_componentWillUpdate: {
    6967        newMethod: 'componentDidUpdate',
    70         details:
    71           'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
     68        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
    7269      },
    7370    };

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unstable-nested-components.js

    rd565449 r0c6b92a  
    66'use strict';
    77
     8const minimatch = require('minimatch');
    89const Components = require('../util/Components');
    910const docsUrl = require('../util/docsUrl');
     11const astUtil = require('../util/ast');
    1012const isCreateElement = require('../util/isCreateElement');
    1113const report = require('../util/report');
    … …  
    2426/**
    2527 * Generate error message with given parent component name
    26  * @param {String} parentName Name of the parent component, if known
    27  * @returns {String} Error message with parent component name
     28 * @param {string} parentName Name of the parent component, if known
     29 * @returns {string} Error message with parent component name
    2830 */
    2931function generateErrorMessageWithParentName(parentName) {
    … …  
    3234
    3335/**
    34  * Check whether given text starts with `render`. Comparison is case-sensitive.
    35  * @param {String} text Text to validate
    36  * @returns {Boolean}
    37  */
    38 function startsWithRender(text) {
    39   return (text || '').startsWith('render');
     36 * Check whether given text matches the pattern passed in.
     37 * @param {string} text Text to validate
     38 * @param {string} pattern Pattern to match against
     39 * @returns {boolean}
     40 */
     41function propMatchesRenderPropPattern(text, pattern) {
     42  return typeof text === 'string' && minimatch(text, pattern);
    4043}
    4144
    … …  
    6366 * @param {ASTNode} node The AST node
    6467 * @param {Context} context eslint context
    65  * @returns {Boolean} True if node is a `createElement` call, false if not
     68 * @returns {boolean} True if node is a `createElement` call, false if not
    6669 */
    6770function isCreateElementMatcher(node, context) {
    6871  return (
    69     node
    70     && node.type === 'CallExpression'
     72    astUtil.isCallExpression(node)
    7173    && isCreateElement(context, node)
    7274  );
    … …  
    7678 * Matcher used to check whether given node is a `ObjectExpression`
    7779 * @param {ASTNode} node The AST node
    78  * @returns {Boolean} True if node is a `ObjectExpression`, false if not
     80 * @returns {boolean} True if node is a `ObjectExpression`, false if not
    7981 */
    8082function isObjectExpressionMatcher(node) {
    … …  
    8587 * Matcher used to check whether given node is a `JSXExpressionContainer`
    8688 * @param {ASTNode} node The AST node
    87  * @returns {Boolean} True if node is a `JSXExpressionContainer`, false if not
     89 * @returns {boolean} True if node is a `JSXExpressionContainer`, false if not
    8890 */
    8991function isJSXExpressionContainerMatcher(node) {
    … …  
    9496 * Matcher used to check whether given node is a `JSXAttribute` of `JSXExpressionContainer`
    9597 * @param {ASTNode} node The AST node
    96  * @returns {Boolean} True if node is a `JSXAttribute` of `JSXExpressionContainer`, false if not
     98 * @returns {boolean} True if node is a `JSXAttribute` of `JSXExpressionContainer`, false if not
    9799 */
    98100function isJSXAttributeOfExpressionContainerMatcher(node) {
    … …  
    108110 * Matcher used to check whether given node is an object `Property`
    109111 * @param {ASTNode} node The AST node
    110  * @returns {Boolean} True if node is a `Property`, false if not
     112 * @returns {boolean} True if node is a `Property`, false if not
    111113 */
    112114function isPropertyOfObjectExpressionMatcher(node) {
    … …  
    116118    && node.parent.type === 'Property'
    117119  );
    118 }
    119 
    120 /**
    121  * Matcher used to check whether given node is a `CallExpression`
    122  * @param {ASTNode} node The AST node
    123  * @returns {Boolean} True if node is a `CallExpression`, false if not
    124  */
    125 function isCallExpressionMatcher(node) {
    126   return node && node.type === 'CallExpression';
    127120}
    128121
    … …  
    133126 * ```
    134127 * @param {ASTNode} node The AST node
    135  * @returns {Boolean} True if node is directly inside `map` call, false if not
     128 * @returns {boolean} True if node is directly inside `map` call, false if not
    136129 */
    137130function isMapCall(node) {
    … …  
    148141 * @param {ASTNode} node The AST node
    149142 * @param {Context} context eslint context
    150  * @returns {Boolean} True if node is a `ReturnStatement` of a React hook, false if not
     143 * @returns {boolean} True if node is a `ReturnStatement` of a React hook, false if not
    151144 */
    152145function isReturnStatementOfHook(node, context) {
    … …  
    159152  }
    160153
    161   const callExpression = getClosestMatchingParent(node, context, isCallExpressionMatcher);
     154  const callExpression = getClosestMatchingParent(node, context, astUtil.isCallExpression);
    162155  return (
    163156    callExpression
    … …  
    175168 * @param {ASTNode} node The AST node
    176169 * @param {Context} context eslint context
    177  * @returns {Boolean} True if component is declared inside a render prop, false if not
    178  */
    179 function isComponentInRenderProp(node, context) {
     170 * @param {string} propNamePattern a pattern to match render props against
     171 * @returns {boolean} True if component is declared inside a render prop, false if not
     172 */
     173function isComponentInRenderProp(node, context, propNamePattern) {
    180174  if (
    181175    node
    … …  
    183177    && node.parent.type === 'Property'
    184178    && node.parent.key
    185     && startsWithRender(node.parent.key.name)
     179    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
    186180  ) {
    187181    return true;
    … …  
    212206
    213207    // Starts with render, e.g. <Component renderFooter={() => <div />} />
    214     if (startsWithRender(propName)) {
     208    if (propMatchesRenderPropPattern(propName, propNamePattern)) {
    215209      return true;
    216210    }
    … …  
    232226 *  ```
    233227 * @param {ASTNode} node The AST node
    234  * @returns {Boolean} True if component is declared inside a render property, false if not
    235  */
    236 function isDirectValueOfRenderProperty(node) {
     228 * @param {string} propNamePattern The pattern to match render props against
     229 * @returns {boolean} True if component is declared inside a render property, false if not
     230 */
     231function isDirectValueOfRenderProperty(node, propNamePattern) {
    237232  return (
    238233    node
    … …  
    241236    && node.parent.key
    242237    && node.parent.key.type === 'Identifier'
    243     && startsWithRender(node.parent.key.name)
     238    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
    244239  );
    245240}
    … …  
    248243 * Resolve the component name of given node
    249244 * @param {ASTNode} node The AST node of the component
    250  * @returns {String} Name of the component, if any
     245 * @returns {string} Name of the component, if any
    251246 */
    252247function resolveComponentName(node) {
    … …  
    287282          type: 'boolean',
    288283        },
     284        propNamePattern: {
     285          type: 'string',
     286        },
    289287      },
    290288      additionalProperties: false,
    … …  
    294292  create: Components.detect((context, components, utils) => {
    295293    const allowAsProps = context.options.some((option) => option && option.allowAsProps);
     294    const propNamePattern = (context.options[0] || {}).propNamePattern || 'render*';
    296295
    297296    /**
    … …  
    304303     * ```
    305304     * @param {ASTNode} node The AST node being checked
    306      * @returns {Boolean} True if node is inside class component's render block, false if not
     305     * @returns {boolean} True if node is inside class component's render block, false if not
    307306     */
    308307    function isInsideRenderMethod(node) {
    … …  
    332331     * ```
    333332     * @param {ASTNode} node The AST node being checked
    334      * @returns {Boolean} True if given node a function component declared inside class component, false if not
     333     * @returns {boolean} True if given node a function component declared inside class component, false if not
    335334     */
    336335    function isFunctionComponentInsideClassComponent(node) {
    … …  
    355354     * ```
    356355     * @param {ASTNode} node The AST node
    357      * @returns {Boolean} True if node is declare inside `createElement` call's props, false if not
     356     * @returns {boolean} True if node is declare inside `createElement` call's props, false if not
    358357     */
    359358    function isComponentInsideCreateElementsProp(node) {
    … …  
    378377     * ```
    379378     * @param {ASTNode} node The AST node being checked
    380      * @returns {Boolean} True if node is a component declared inside prop, false if not
     379     * @returns {boolean} True if node is a component declared inside prop, false if not
    381380     */
    382381    function isComponentInProp(node) {
    … …  
    400399     * ```
    401400     * @param {ASTNode} node The AST node being checked
    402      * @returns {Boolean} True if node is a stateless component returning non-JSX, false if not
     401     * @returns {boolean} True if node is a stateless component returning non-JSX, false if not
    403402     */
    404403    function isStatelessComponentReturningNull(node) {
    … …  
    428427      if (
    429428        // Support allowAsProps option
    430         (isDeclaredInsideProps && (allowAsProps || isComponentInRenderProp(node, context)))
     429        (isDeclaredInsideProps && (allowAsProps || isComponentInRenderProp(node, context, propNamePattern)))
    431430
    432431        // Prevent reporting components created inside Array.map calls
    … …  
    438437
    439438        // Do not mark objects containing render methods
    440         || isDirectValueOfRenderProperty(node)
     439        || isDirectValueOfRenderProperty(node, propNamePattern)
    441440
    442441        // Prevent reporting nested class components twice

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unused-class-component-methods.js

    rd565449 r0c6b92a  
    9999};
    100100
     101/** @type {import('eslint').Rule.RuleModule} */
    101102module.exports = {
    102103  meta: {
    … …  
    249250            .filter((prop) => prop.type === 'Property' && isKeyLiteralLike(prop, prop.key))
    250251            .forEach((prop) => {
    251               addUsedProperty(prop.key);
     252              addUsedProperty('key' in prop ? prop.key : undefined);
    252253            });
    253254        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unused-prop-types.js

    rd565449 r0c6b92a  
    1414const docsUrl = require('../util/docsUrl');
    1515const report = require('../util/report');
     16
     17/**
     18 * Checks if the component must be validated
     19 * @param {Object} component The component to process
     20 * @returns {boolean} True if the component must be validated, false if not.
     21 */
     22function mustBeValidated(component) {
     23  return !!component && !component.ignoreUnusedPropTypesValidation;
     24}
    1625
    1726// ------------------------------------------------------------------------------
    … …  
    6574    /**
    6675     * Checks if the prop is ignored
    67      * @param {String} name Name of the prop to check.
    68      * @returns {Boolean} True if the prop is ignored, false if not.
     76     * @param {string} name Name of the prop to check.
     77     * @returns {boolean} True if the prop is ignored, false if not.
    6978     */
    7079    function isIgnored(name) {
    … …  
    7382
    7483    /**
    75      * Checks if the component must be validated
    76      * @param {Object} component The component to process
    77      * @returns {Boolean} True if the component must be validated, false if not.
    78      */
    79     function mustBeValidated(component) {
    80       return Boolean(
    81         component
    82         && !component.ignoreUnusedPropTypesValidation
    83       );
    84     }
    85 
    86     /**
    8784     * Checks if a prop is used
    8885     * @param {ASTNode} node The AST node being checked.
    8986     * @param {Object} prop Declared prop object
    90      * @returns {Boolean} True if the prop is used, false if not.
     87     * @returns {boolean} True if the prop is used, false if not.
    9188     */
    9289    function isPropUsed(node, prop) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/no-unused-state.js

    rd565449 r0c6b92a  
    1111
    1212const docsUrl = require('../util/docsUrl');
    13 const ast = require('../util/ast');
     13const astUtil = require('../util/ast');
    1414const componentUtil = require('../util/componentUtil');
    1515const report = require('../util/report');
    … …  
    4545
    4646function isThisExpression(node) {
    47   return ast.unwrapTSAsExpression(uncast(node)).type === 'ThisExpression';
     47  return astUtil.unwrapTSAsExpression(uncast(node)).type === 'ThisExpression';
    4848}
    4949
    … …  
    6666
    6767function isSetStateCall(node) {
    68   const unwrappedCalleeNode = ast.unwrapTSAsExpression(node.callee);
     68  const unwrappedCalleeNode = astUtil.unwrapTSAsExpression(node.callee);
    6969
    7070  return (
    … …  
    7979};
    8080
     81/** @type {import('eslint').Rule.RuleModule} */
    8182module.exports = {
    8283  meta: {
    … …  
    175176    // destructures `this.state`.
    176177    function handleStateDestructuring(node) {
    177       for (const prop of node.properties) {
     178      node.properties.forEach((prop) => {
    178179        if (prop.type === 'Property') {
    179180          addUsedStateField(prop.key);
    … …  
    184185          classInfo.aliases.add(getName(prop.argument));
    185186        }
    186       }
     187      });
    187188    }
    188189
    … …  
    190191    // AssignmentExpressions and VariableDeclarators.
    191192    function handleAssignment(left, right) {
    192       const unwrappedRight = ast.unwrapTSAsExpression(right);
     193      const unwrappedRight = astUtil.unwrapTSAsExpression(right);
    193194
    194195      switch (left.type) {
    … …  
    202203            handleStateDestructuring(left);
    203204          } else if (isThisExpression(unwrappedRight) && classInfo.aliases) {
    204             for (const prop of left.properties) {
     205            left.properties.forEach((prop) => {
    205206              if (prop.type === 'Property' && getName(prop.key) === 'state') {
    206207                const name = getName(prop.value);
    … …  
    211212                }
    212213              }
    213             }
     214            });
    214215          }
    215216          break;
    … …  
    221222    function reportUnusedFields() {
    222223      // Report all unused state fields.
    223       for (const node of classInfo.stateFields) {
     224      classInfo.stateFields.forEach((node) => {
    224225        const name = getName(node.key);
    225226        if (!classInfo.usedStateFields.has(name)) {
    … …  
    231232          });
    232233        }
    233       }
     234      });
    234235    }
    235236
    … …  
    293294        }
    294295
    295         const unwrappedNode = ast.unwrapTSAsExpression(node);
    296         const unwrappedArgumentNode = ast.unwrapTSAsExpression(unwrappedNode.arguments[0]);
     296        const unwrappedNode = astUtil.unwrapTSAsExpression(node);
     297        const unwrappedArgumentNode = astUtil.unwrapTSAsExpression(unwrappedNode.arguments[0]);
    297298
    298299        // If we're looking at a `this.setState({})` invocation, record all the
    … …  
    309310          && unwrappedArgumentNode.type === 'ArrowFunctionExpression'
    310311        ) {
    311           const unwrappedBodyNode = ast.unwrapTSAsExpression(unwrappedArgumentNode.body);
     312          const unwrappedBodyNode = astUtil.unwrapTSAsExpression(unwrappedArgumentNode.body);
    312313
    313314          if (unwrappedBodyNode.type === 'ObjectExpression') {
    … …  
    331332        // If we see state being assigned as a class property using an object
    332333        // expression, record all the fields of that object as state fields.
    333         const unwrappedValueNode = ast.unwrapTSAsExpression(node.value);
     334        const unwrappedValueNode = astUtil.unwrapTSAsExpression(node.value);
    334335
    335336        const name = getName(node.key);
    … …  
    432433        }
    433434
    434         if (parent.key.name === 'getInitialState') {
     435        if (
     436          'key' in parent
     437          && 'name' in parent.key
     438          && parent.key.name === 'getInitialState'
     439        ) {
    435440          const body = node.body.body;
    436441          const lastBodyNode = body[body.length - 1];
    … …  
    453458        }
    454459
    455         const unwrappedLeft = ast.unwrapTSAsExpression(node.left);
    456         const unwrappedRight = ast.unwrapTSAsExpression(node.right);
     460        const unwrappedLeft = astUtil.unwrapTSAsExpression(node.left);
     461        const unwrappedRight = astUtil.unwrapTSAsExpression(node.right);
    457462
    458463        // Check for assignments like `this.state = {}`
    … …  
    464469        ) {
    465470          // Find the nearest function expression containing this assignment.
     471          /** @type {import("eslint").Rule.Node} */
    466472          let fn = node;
    467473          while (fn.type !== 'FunctionExpression' && fn.parent) {
    … …  
    494500          return;
    495501        }
    496         if (isStateReference(ast.unwrapTSAsExpression(node.object))) {
     502        if (isStateReference(astUtil.unwrapTSAsExpression(node.object))) {
    497503          // If we see this.state[foo] access, give up.
    498504          if (node.computed && node.property.type !== 'Literal') {
    … …  
    503509          addUsedStateField(node.property);
    504510        // If we see a `this.state` access in a CallExpression, give up.
    505         } else if (isStateReference(node) && node.parent.type === 'CallExpression') {
     511        } else if (isStateReference(node) && astUtil.isCallExpression(node.parent)) {
    506512          classInfo = null;
    507513        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/prefer-exact-props.js

    rd565449 r0c6b92a  
    77const Components = require('../util/Components');
    88const docsUrl = require('../util/docsUrl');
     9const astUtil = require('../util/ast');
    910const propsUtil = require('../util/props');
    1011const propWrapperUtil = require('../util/propWrapper');
    … …  
    8283    function isNonExactPropWrapperFunction(node) {
    8384      return (
    84         node
    85         && node.type === 'CallExpression'
     85        astUtil.isCallExpression(node)
    8686        && !propWrapperUtil.isExactPropWrapperFunction(context, getText(context, node.callee))
    8787      );

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/prefer-stateless-function.js

    rd565449 r0c6b92a  
    7171        body.length === 1
    7272        && body[0].type === 'ExpressionStatement'
    73         && body[0].expression.type === 'CallExpression'
     73        && astUtil.isCallExpression(body[0].expression)
    7474        && body[0].expression.callee.type === 'Super'
    7575      );
    … …  
    192192     * Check if a given AST node have any other properties the ones available in stateless components
    193193     * @param {ASTNode} node The AST node being checked.
    194      * @returns {Boolean} True if the node has at least one other property, false if not.
     194     * @returns {boolean} True if the node has at least one other property, false if not.
    195195     */
    196196    function hasOtherProperties(node) {
    … …  
    355355          scope = scope.upper;
    356356        }
    357         const isRender = blockNode && blockNode.key && blockNode.key.name === 'render';
     357        const isRender = blockNode
     358          && blockNode.key
     359          && blockNode.key.name === 'render';
    358360        const allowNull = testReactVersion(context, '>= 15.0.0'); // Stateless components can return null since React 15
    359361        const isReturningJSX = utils.isReturningJSX(node, !allowNull);

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/prop-types.js

    rd565449 r0c6b92a  
    6565    /**
    6666     * Checks if the prop is ignored
    67      * @param {String} name Name of the prop to check.
    68      * @returns {Boolean} True if the prop is ignored, false if not.
     67     * @param {string} name Name of the prop to check.
     68     * @returns {boolean} True if the prop is ignored, false if not.
    6969     */
    7070    function isIgnored(name) {
    … …  
    9090     * Internal: Checks if the prop is declared
    9191     * @param {Object} declaredPropTypes Description of propTypes declared in the current component
    92      * @param {String[]} keyList Dot separated name of the prop to check.
     92     * @param {string[]} keyList Dot separated name of the prop to check.
    9393     * @returns {boolean} True if the prop is declared, false if not.
    9494     */
    … …  
    149149     * Checks if the prop is declared
    150150     * @param {ASTNode} node The AST node being checked.
    151      * @param {String[]} names List of names of the prop to check.
    152      * @returns {Boolean} True if the prop is declared, false if not.
     151     * @param {string[]} names List of names of the prop to check.
     152     * @returns {boolean} True if the prop is declared, false if not.
    153153     */
    154154    function isDeclaredInComponent(node, names) {
    … …  
    191191     * @param {Object} component The current component to process
    192192     * @param {Array} list The all components to process
    193      * @returns {Boolean} True if the component is nested False if not.
     193     * @returns {boolean} True if the component is nested False if not.
    194194     */
    195195    function checkNestedComponent(component, list) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/require-optimization.js

    rd565449 r0c6b92a  
    5151     * Checks to see if our component is decorated by PureRenderMixin via reactMixin
    5252     * @param {ASTNode} node The AST node being checked.
    53      * @returns {Boolean} True if node is decorated with a PureRenderMixin, false if not.
     53     * @returns {boolean} True if node is decorated with a PureRenderMixin, false if not.
    5454     */
    5555    function hasPureRenderDecorator(node) {
    … …  
    7878     * Checks to see if our component is custom decorated
    7979     * @param {ASTNode} node The AST node being checked.
    80      * @returns {Boolean} True if node is decorated name with a custom decorated, false if not.
     80     * @returns {boolean} True if node is decorated name with a custom decorated, false if not.
    8181     */
    8282    function hasCustomDecorator(node) {
    … …  
    8686        for (let i = 0; i < allowLength; i++) {
    8787          for (let j = 0, l = node.decorators.length; j < l; j++) {
     88            const expression = node.decorators[j].expression;
    8889            if (
    89               node.decorators[j].expression
    90               && node.decorators[j].expression.name === allowDecorators[i]
     90              expression
     91              && expression.name === allowDecorators[i]
    9192            ) {
    9293              return true;
    … …  
    102103     * Checks if we are declaring a shouldComponentUpdate method
    103104     * @param {ASTNode} node The AST node being checked.
    104      * @returns {Boolean} True if we are declaring a shouldComponentUpdate method, false if not.
     105     * @returns {boolean} True if we are declaring a shouldComponentUpdate method, false if not.
    105106     */
    106107    function isSCUDeclared(node) {
    107       return Boolean(
    108         node
    109         && node.name === 'shouldComponentUpdate'
    110       );
     108      return !!node && node.name === 'shouldComponentUpdate';
    111109    }
    112110
    … …  
    114112     * Checks if we are declaring a PureRenderMixin mixin
    115113     * @param {ASTNode} node The AST node being checked.
    116      * @returns {Boolean} True if we are declaring a PureRenderMixin method, false if not.
     114     * @returns {boolean} True if we are declaring a PureRenderMixin method, false if not.
    117115     */
    118116    function isPureRenderDeclared(node) {
    … …  
    127125      }
    128126
    129       return Boolean(
    130         node
     127      return (
     128        !!node
    131129        && node.key.name === 'mixins'
    132130        && hasPR

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/self-closing-comp.js

    rd565449 r0c6b92a  
    1010const report = require('../util/report');
    1111
     12const optionDefaults = { component: true, html: true };
     13
     14function isComponent(node) {
     15  return (
     16    node.name
     17    && (node.name.type === 'JSXIdentifier' || node.name.type === 'JSXMemberExpression')
     18    && !jsxUtil.isDOMComponent(node)
     19  );
     20}
     21
     22function childrenIsEmpty(node) {
     23  return node.parent.children.length === 0;
     24}
     25
     26function childrenIsMultilineSpaces(node) {
     27  const childrens = node.parent.children;
     28
     29  return (
     30    childrens.length === 1
     31    && (childrens[0].type === 'Literal' || childrens[0].type === 'JSXText')
     32    && childrens[0].value.indexOf('\n') !== -1
     33    && childrens[0].value.replace(/(?!\xA0)\s/g, '') === ''
     34  );
     35}
     36
    1237// ------------------------------------------------------------------------------
    1338// Rule Definition
    1439// ------------------------------------------------------------------------------
    15 
    16 const optionDefaults = { component: true, html: true };
    1740
    1841const messages = {
    … …  
    5073
    5174  create(context) {
    52     function isComponent(node) {
    53       return (
    54         node.name
    55         && (node.name.type === 'JSXIdentifier' || node.name.type === 'JSXMemberExpression')
    56         && !jsxUtil.isDOMComponent(node)
    57       );
    58     }
    59 
    60     function childrenIsEmpty(node) {
    61       return node.parent.children.length === 0;
    62     }
    63 
    64     function childrenIsMultilineSpaces(node) {
    65       const childrens = node.parent.children;
    66 
    67       return (
    68         childrens.length === 1
    69         && (childrens[0].type === 'Literal' || childrens[0].type === 'JSXText')
    70         && childrens[0].value.indexOf('\n') !== -1
    71         && childrens[0].value.replace(/(?!\xA0)\s/g, '') === ''
    72       );
    73     }
    74 
    7575    function isShouldBeSelfClosed(node) {
    7676      const configuration = Object.assign({}, optionDefaults, context.options[0]);

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/sort-comp.js

    rd565449 r0c6b92a  
    235235     * Get properties name
    236236     * @param {Object} node - Property.
    237      * @returns {String} Property name.
     237     * @returns {string} Property name.
    238238     */
    239239    function getPropertyName(node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/sort-default-props.js

    rd565449 r0c6b92a  
    2323};
    2424
     25/** @type {import('eslint').Rule.RuleModule} */
    2526module.exports = {
    2627  meta: {
    … …  
    5354     * Get properties name
    5455     * @param {Object} node - Property.
    55      * @returns {String} Property name.
     56     * @returns {string} Property name.
    5657     */
    5758    function getPropertyName(node) {
    … …  
    7475     * Checks if the Identifier node passed in looks like a defaultProps declaration.
    7576     * @param   {ASTNode}  node The node to check. Must be an Identifier node.
    76      * @returns {Boolean}       `true` if the node is a defaultProps declaration, `false` if not
     77     * @returns {boolean}       `true` if the node is a defaultProps declaration, `false` if not
    7778     */
    7879    function isDefaultPropsDeclaration(node) {
    … …  
    173174        }
    174175
    175         checkNode(node.parent.right);
     176        checkNode('right' in node.parent && node.parent.right);
    176177      },
    177178    };

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/sort-prop-types.js

    rd565449 r0c6b92a  
    55'use strict';
    66
     7const astUtil = require('../util/ast');
    78const variableUtil = require('../util/variable');
    89const propsUtil = require('../util/props');
    … …  
    3435  }
    3536  return getText(context, node.key || node.argument);
    36 }
    37 
    38 function getValueName(node) {
    39   return node.type === 'Property' && node.value.property && node.value.property.name;
    40 }
    41 
    42 function isCallbackPropName(propName) {
    43   return /^on[A-Z]/.test(propName);
    44 }
    45 
    46 function isRequiredProp(node) {
    47   return getValueName(node) === 'isRequired';
    48 }
    49 
    50 function isShapeProp(node) {
    51   return Boolean(
    52     node && node.callee && node.callee.property && node.callee.property.name === 'shape'
    53   );
    54 }
    55 
    56 function toLowerCase(item) {
    57   return String(item).toLowerCase();
    5837}
    5938
    … …  
    146125        let prevPropName = getKey(context, prev);
    147126        let currentPropName = getKey(context, curr);
    148         const previousIsRequired = isRequiredProp(prev);
    149         const currentIsRequired = isRequiredProp(curr);
    150         const previousIsCallback = isCallbackPropName(prevPropName);
    151         const currentIsCallback = isCallbackPropName(currentPropName);
     127        const previousIsRequired = propTypesSortUtil.isRequiredProp(prev);
     128        const currentIsRequired = propTypesSortUtil.isRequiredProp(curr);
     129        const previousIsCallback = propTypesSortUtil.isCallbackPropName(prevPropName);
     130        const currentIsCallback = propTypesSortUtil.isCallbackPropName(currentPropName);
    152131
    153132        if (ignoreCase) {
    154           prevPropName = toLowerCase(prevPropName);
    155           currentPropName = toLowerCase(currentPropName);
     133          prevPropName = String(prevPropName).toLowerCase();
     134          currentPropName = String(currentPropName).toLowerCase();
    156135        }
    157136
    … …  
    208187
    209188    function checkNode(node) {
    210       switch (node && node.type) {
    211         case 'ObjectExpression':
    212           checkSorted(node.properties);
    213           break;
    214         case 'Identifier': {
    215           const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
    216           if (propTypesObject && propTypesObject.properties) {
    217             checkSorted(propTypesObject.properties);
    218           }
    219           break;
    220         }
    221         case 'CallExpression': {
    222           const innerNode = node.arguments && node.arguments[0];
    223           if (propWrapperUtil.isPropWrapperFunction(context, node.callee.name) && innerNode) {
    224             checkNode(innerNode);
    225           }
    226           break;
    227         }
    228         default:
    229           break;
     189      if (!node) {
     190        return;
     191      }
     192
     193      if (node.type === 'ObjectExpression') {
     194        checkSorted(node.properties);
     195      } else if (node.type === 'Identifier') {
     196        const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
     197        if (propTypesObject && propTypesObject.properties) {
     198          checkSorted(propTypesObject.properties);
     199        }
     200      } else if (astUtil.isCallExpression(node)) {
     201        const innerNode = node.arguments && node.arguments[0];
     202        if (propWrapperUtil.isPropWrapperFunction(context, node.callee.name) && innerNode) {
     203          checkNode(innerNode);
     204        }
    230205      }
    231206    }
    … …  
    261236    return Object.assign({
    262237      CallExpression(node) {
    263         if (!sortShapeProp || !isShapeProp(node) || !(node.arguments && node.arguments[0])) {
     238        if (!sortShapeProp || !propTypesSortUtil.isShapeProp(node) || !(node.arguments && node.arguments[0])) {
    264239          return;
    265240        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/static-property-placement.js

    rd565449 r0c6b92a  
    100100      * Checks if we are declaring context in class
    101101      * @param {ASTNode} node
    102       * @returns {Boolean} True if we are declaring context in class, false if not.
     102      * @returns {boolean} True if we are declaring context in class, false if not.
    103103     */
    104104    function isContextInClass(node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/style-prop-object.js

    rd565449 r0c6b92a  
    1919};
    2020
     21/** @type {import('eslint').Rule.RuleModule} */
    2122module.exports = {
    2223  meta: {
    … …  
    8182          && node.arguments.length > 1
    8283        ) {
    83           if (node.arguments[0].name) {
     84          if ('name' in node.arguments[0] && node.arguments[0].name) {
    8485            // store name of component
    8586            const componentName = node.arguments[0].name;
    … …  
    9293          }
    9394          if (node.arguments[1].type === 'ObjectExpression') {
    94             const style = node.arguments[1].properties.find((property) => property.key && property.key.name === 'style' && !property.computed);
    95             if (style) {
     95            const style = node.arguments[1].properties.find((property) => (
     96              'key' in property
     97              && property.key
     98              && 'name' in property.key
     99              && property.key.name === 'style'
     100              && !property.computed
     101            ));
     102
     103            if (style && 'value' in style) {
    96104              if (style.value.type === 'Identifier') {
    97105                checkIdentifiers(style.value);

  • imaps-frontend/node_modules/eslint-plugin-react/lib/rules/void-dom-elements-no-children.js

    rd565449 r0c6b92a  
    4848const noChildrenInVoidEl = 'Void DOM element <{{element}} /> cannot receive children.';
    4949
     50/** @type {import('eslint').Rule.RuleModule} */
    5051module.exports = {
    5152  meta: {
    … …  
    120121      }
    121122
    122       const elementName = args[0].value;
     123      const elementName = 'value' in args[0] ? args[0].value : undefined;
    123124
    124125      if (!isVoidDOMElement(elementName)) {
    … …  
    145146
    146147      const hasChildrenPropOrDanger = props.some((prop) => {
    147         if (!prop.key) {
     148        if (!('key' in prop) || !prop.key || !('name' in prop.key)) {
    148149          return false;
    149150        }
Note: See TracChangeset for help on using the changeset viewer.