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
Files:
265 added
86 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        }

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/Components.js

    rd565449 r0c6b92a  
    7171   *
    7272   * @param {ASTNode} node The AST node being added.
    73    * @param {Number} confidence Confidence in the component detection (0=banned, 1=maybe, 2=yes)
     73   * @param {number} confidence Confidence in the component detection (0=banned, 1=maybe, 2=yes)
    7474   * @returns {Object} Added component object
    7575   */
    … …  
    184184   * Components for which we are not confident are not counted
    185185   *
    186    * @returns {Number} Components list length
     186   * @returns {number} Components list length
    187187   */
    188188  length() {
    … …  
    304304
    305305    /**
    306      * @param {ASTNode} ASTNode
     306     * @param {ASTNode} node
    307307     * @param {boolean=} strict
    308308     * @returns {boolean}
    309309     */
    310     isReturningJSX(ASTNode, strict) {
    311       return jsxUtil.isReturningJSX(context, ASTNode, strict, true);
    312     },
    313 
    314     isReturningJSXOrNull(ASTNode, strict) {
    315       return jsxUtil.isReturningJSX(context, ASTNode, strict);
    316     },
    317 
    318     isReturningOnlyNull(ASTNode) {
    319       return jsxUtil.isReturningOnlyNull(ASTNode, context);
     310    isReturningJSX(node, strict) {
     311      return jsxUtil.isReturningJSX(context, node, strict, true);
     312    },
     313
     314    isReturningJSXOrNull(node, strict) {
     315      return jsxUtil.isReturningJSX(context, node, strict);
     316    },
     317
     318    isReturningOnlyNull(node) {
     319      return jsxUtil.isReturningOnlyNull(node, context);
    320320    },
    321321
    … …  
    408408
    409409    isPragmaComponentWrapper(node) {
    410       if (!node || node.type !== 'CallExpression') {
     410      if (!astUtil.isCallExpression(node)) {
    411411        return false;
    412412      }
    … …  
    568568
    569569        // for case abc = { [someobject.somekey]: props => { ... return not-jsx } }
    570         if (node.parent && node.parent.key && node.parent.key.type === 'MemberExpression' && !utils.isReturningJSX(node) && !utils.isReturningOnlyNull(node)) {
     570        if (
     571          node.parent
     572          && node.parent.key
     573          && node.parent.key.type === 'MemberExpression'
     574          && !utils.isReturningJSX(node)
     575          && !utils.isReturningOnlyNull(node)
     576        ) {
    571577          return undefined;
    572578        }
    … …  
    578584          )
    579585        ) {
    580           if (isFirstLetterCapitalized(node.parent.key.name) && utils.isReturningJSX(node)) {
     586          if (
     587            isFirstLetterCapitalized(node.parent.key.name)
     588            && utils.isReturningJSX(node)
     589          ) {
    581590            return node;
    582591          }
    … …  
    642651     *
    643652     * @param {ASTNode} node The AST node being checked (must be a MemberExpression).
    644      * @returns {ASTNode} component node, null if we cannot find the component
     653     * @returns {ASTNode | null} component node, null if we cannot find the component
    645654     */
    646655    getRelatedComponent(node) {
    … …  
    752761     * @param {ASTNode} node The AST node being searched. (expects CallExpression)
    753762     * @param {('useCallback'|'useContext'|'useDebugValue'|'useEffect'|'useImperativeHandle'|'useLayoutEffect'|'useMemo'|'useReducer'|'useRef'|'useState')[]} [expectedHookNames] React hook names to which search is limited.
    754      * @returns {Boolean} True if the node is a call to a React hook
     763     * @returns {boolean} True if the node is a call to a React hook
    755764     */
    756765    isReactHookCall(node, expectedHookNames) {
    757       if (node.type !== 'CallExpression') {
     766      if (!astUtil.isCallExpression(node)) {
    758767        return false;
    759768      }
    … …  
    799808
    800809      const hookResolvedDefs = potentialHookReference && potentialHookReference.resolved.defs;
    801       const localHookName = (isPotentialReactHookCall && node.callee.property.name)
    802         || (isPotentialHookCall && potentialHookReference && node.callee.name);
     810      const localHookName = (
     811        isPotentialReactHookCall
     812        && node.callee.property.name
     813      ) || (
     814        isPotentialHookCall
     815        && potentialHookReference
     816        && node.callee.name
     817      );
    803818      const isHookShadowed = isPotentialHookCall
    804819        && hookResolvedDefs
    … …  
    877892      }
    878893
    879       node = utils.getStatelessComponent(node);
    880       if (!node) {
    881         return;
    882       }
    883       components.add(node, 2);
     894      const cNode = utils.getStatelessComponent(node);
     895      if (!cNode) {
     896        return;
     897      }
     898      components.add(cNode, 2);
    884899    },
    885900

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/annotations.js

    rd565449 r0c6b92a  
    1313 * @param {ASTNode} node The AST node being checked.
    1414 * @param {Object} context
    15  * @returns {Boolean} True if the node is a type annotated props declaration, false if not.
     15 * @returns {boolean} True if the node is a type annotated props declaration, false if not.
    1616 */
    1717function isAnnotatedFunctionPropsDeclaration(node, context) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/ast.js

    rd565449 r0c6b92a  
    9393
    9494  /* TODO: properly warn on React.forwardRefs having typo properties
    95   if (nodeType === 'CallExpression') {
     95  if (astUtil.isCallExpression(ASTNode)) {
    9696    const callee = ASTNode.callee;
    9797    const pragma = pragmaUtil.getFromContext(context);
    … …  
    149149 */
    150150function getPropertyNameNode(node) {
    151   if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
     151  if (
     152    node.key
     153    || node.type === 'MethodDefinition'
     154    || node.type === 'Property'
     155  ) {
    152156    return node.key;
    153157  }
    … …  
    161165 * Get properties name
    162166 * @param {Object} node - Property.
    163  * @returns {String} Property name.
     167 * @returns {string} Property name.
    164168 */
    165169function getPropertyName(node) {
    … …  
    211215 * @param {Object} context The node to check
    212216 * @param {ASTNode} node The node to check
    213  * @return {Boolean} true if it's the first node in its line
     217 * @return {boolean} true if it's the first node in its line
    214218 */
    215219function isNodeFirstInLine(context, node) {
    … …  
    223227 * Checks if the node is a function or arrow function expression.
    224228 * @param {ASTNode} node The node to check
    225  * @return {Boolean} true if it's a function-like expression
     229 * @return {boolean} true if it's a function-like expression
    226230 */
    227231function isFunctionLikeExpression(node) {
    … …  
    232236 * Checks if the node is a function.
    233237 * @param {ASTNode} node The node to check
    234  * @return {Boolean} true if it's a function
     238 * @return {boolean} true if it's a function
    235239 */
    236240function isFunction(node) {
    … …  
    241245 * Checks if node is a function declaration or expression or arrow function.
    242246 * @param {ASTNode} node The node to check
    243  * @return {Boolean} true if it's a function-like
     247 * @return {boolean} true if it's a function-like
    244248 */
    245249function isFunctionLike(node) {
    … …  
    250254 * Checks if the node is a class.
    251255 * @param {ASTNode} node The node to check
    252  * @return {Boolean} true if it's a class
     256 * @return {boolean} true if it's a class
    253257 */
    254258function isClass(node) {
    … …  
    330334 * Checks if a node is being assigned a value: props.bar = 'bar'
    331335 * @param {ASTNode} node The AST node being checked.
    332  * @returns {Boolean}
     336 * @returns {boolean}
    333337 */
    334338function isAssignmentLHS(node) {
    … …  
    340344}
    341345
     346function isTSAsExpression(node) {
     347  return node && node.type === 'TSAsExpression';
     348}
     349
     350/**
     351 * Matcher used to check whether given node is a `CallExpression`
     352 * @param {ASTNode} node The AST node
     353 * @returns {boolean} True if node is a `CallExpression`, false if not
     354 */
     355function isCallExpression(node) {
     356  return node && node.type === 'CallExpression';
     357}
     358
    342359/**
    343360 * Extracts the expression node that is wrapped inside a TS type assertion
    … …  
    347364 */
    348365function unwrapTSAsExpression(node) {
    349   if (node && node.type === 'TSAsExpression') return node.expression;
    350   return node;
     366  return isTSAsExpression(node) ? node.expression : node;
    351367}
    352368
    353369function isTSTypeReference(node) {
    354370  if (!node) return false;
    355   const nodeType = node.type;
    356   return nodeType === 'TSTypeReference';
     371
     372  return node.type === 'TSTypeReference';
    357373}
    358374
    359375function isTSTypeAnnotation(node) {
    360   if (!node) return false;
    361   const nodeType = node.type;
    362   return nodeType === 'TSTypeAnnotation';
     376  if (!node) { return false; }
     377
     378  return node.type === 'TSTypeAnnotation';
    363379}
    364380
    365381function isTSTypeLiteral(node) {
    366   if (!node) return false;
    367   const nodeType = node.type;
    368   return nodeType === 'TSTypeLiteral';
     382  if (!node) { return false; }
     383
     384  return node.type === 'TSTypeLiteral';
    369385}
    370386
    371387function isTSIntersectionType(node) {
    372   if (!node) return false;
    373   const nodeType = node.type;
    374   return nodeType === 'TSIntersectionType';
     388  if (!node) { return false; }
     389
     390  return node.type === 'TSIntersectionType';
    375391}
    376392
    377393function isTSInterfaceHeritage(node) {
    378   if (!node) return false;
    379   const nodeType = node.type;
    380   return nodeType === 'TSInterfaceHeritage';
     394  if (!node) { return false; }
     395
     396  return node.type === 'TSInterfaceHeritage';
    381397}
    382398
    383399function isTSInterfaceDeclaration(node) {
    384   if (!node) return false;
    385   let nodeType = node.type;
     400  if (!node) { return false; }
     401
     402  return (node.type === 'ExportNamedDeclaration' && node.declaration
     403    ? node.declaration.type
     404    : node.type
     405  ) === 'TSInterfaceDeclaration';
     406}
     407
     408function isTSTypeDeclaration(node) {
     409  if (!node) { return false; }
     410
     411  const nodeToCheck = node.type === 'ExportNamedDeclaration' && node.declaration
     412    ? node.declaration
     413    : node;
     414
     415  return nodeToCheck.type === 'VariableDeclaration' && nodeToCheck.kind === 'type';
     416}
     417
     418function isTSTypeAliasDeclaration(node) {
     419  if (!node) { return false; }
     420
    386421  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
    387     nodeType = node.declaration.type;
    388   }
    389   return nodeType === 'TSInterfaceDeclaration';
    390 }
    391 
    392 function isTSTypeDeclaration(node) {
    393   if (!node) return false;
    394   let nodeType = node.type;
    395   let nodeKind = node.kind;
    396   if (node.type === 'ExportNamedDeclaration' && node.declaration) {
    397     nodeType = node.declaration.type;
    398     nodeKind = node.declaration.kind;
    399   }
    400   return nodeType === 'VariableDeclaration' && nodeKind === 'type';
    401 }
    402 
    403 function isTSTypeAliasDeclaration(node) {
    404   if (!node) return false;
    405   let nodeType = node.type;
    406   if (node.type === 'ExportNamedDeclaration' && node.declaration) {
    407     nodeType = node.declaration.type;
    408     return nodeType === 'TSTypeAliasDeclaration' && node.exportKind === 'type';
    409   }
    410   return nodeType === 'TSTypeAliasDeclaration';
     422    return node.declaration.type === 'TSTypeAliasDeclaration' && node.exportKind === 'type';
     423  }
     424  return node.type === 'TSTypeAliasDeclaration';
    411425}
    412426
    413427function isTSParenthesizedType(node) {
    414   if (!node) return false;
    415   const nodeType = node.type;
    416   return nodeType === 'TSTypeAliasDeclaration';
     428  if (!node) { return false; }
     429
     430  return node.type === 'TSTypeAliasDeclaration';
    417431}
    418432
    419433function isTSFunctionType(node) {
    420   if (!node) return false;
    421   const nodeType = node.type;
    422   return nodeType === 'TSFunctionType';
     434  if (!node) { return false; }
     435
     436  return node.type === 'TSFunctionType';
    423437}
    424438
    425439function isTSTypeQuery(node) {
    426   if (!node) return false;
    427   const nodeType = node.type;
    428   return nodeType === 'TSTypeQuery';
     440  if (!node) { return false; }
     441
     442  return node.type === 'TSTypeQuery';
    429443}
    430444
    431445function isTSTypeParameterInstantiation(node) {
    432   if (!node) return false;
    433   const nodeType = node.type;
    434   return nodeType === 'TSTypeParameterInstantiation';
     446  if (!node) { return false; }
     447
     448  return node.type === 'TSTypeParameterInstantiation';
    435449}
    436450
    437451module.exports = {
    438   traverse,
    439452  findReturnStatement,
     453  getComponentProperties,
    440454  getFirstNodeInLine,
     455  getKeyValue,
    441456  getPropertyName,
    442457  getPropertyNameNode,
    443   getComponentProperties,
    444   getKeyValue,
    445   isParenthesized,
     458  inConstructor,
    446459  isAssignmentLHS,
     460  isCallExpression,
    447461  isClass,
    448462  isFunction,
     463  isFunctionLike,
    449464  isFunctionLikeExpression,
    450   isFunctionLike,
    451   inConstructor,
    452465  isNodeFirstInLine,
     466  isParenthesized,
     467  isTSAsExpression,
     468  isTSFunctionType,
     469  isTSInterfaceDeclaration,
     470  isTSInterfaceHeritage,
     471  isTSIntersectionType,
     472  isTSParenthesizedType,
     473  isTSTypeAliasDeclaration,
     474  isTSTypeAnnotation,
     475  isTSTypeDeclaration,
     476  isTSTypeLiteral,
     477  isTSTypeParameterInstantiation,
     478  isTSTypeQuery,
     479  isTSTypeReference,
     480  traverse,
     481  traverseReturns,
    453482  unwrapTSAsExpression,
    454   traverseReturns,
    455   isTSTypeReference,
    456   isTSTypeAnnotation,
    457   isTSTypeLiteral,
    458   isTSIntersectionType,
    459   isTSInterfaceHeritage,
    460   isTSInterfaceDeclaration,
    461   isTSTypeAliasDeclaration,
    462   isTSParenthesizedType,
    463   isTSFunctionType,
    464   isTSTypeQuery,
    465   isTSTypeParameterInstantiation,
    466   isTSTypeDeclaration,
    467483};

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/componentUtil.js

    rd565449 r0c6b92a  
    175175 */
    176176function isStateMemberExpression(node) {
    177   return node.type === 'MemberExpression' && node.object.type === 'ThisExpression' && node.property.name === 'state';
     177  return node.type === 'MemberExpression'
     178    && node.object.type === 'ThisExpression'
     179    && node.property.name === 'state';
    178180}
    179181

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/defaultProps.js

    rd565449 r0c6b92a  
    2727    }
    2828    if (
    29       node.type === 'CallExpression'
     29      astUtil.isCallExpression(node)
    3030      && propWrapperUtil.isPropWrapperFunction(context, node.callee.name)
    3131      && node.arguments && node.arguments[0]

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/error.js

    rd565449 r0c6b92a  
    33/**
    44 * Logs out a message if there is no format option set.
    5  * @param {String} message - Message to log.
     5 * @param {string} message - Message to log.
    66 */
    77function error(message) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/isCreateContext.js

    rd565449 r0c6b92a  
    11'use strict';
     2
     3const astUtil = require('./ast');
    24
    35/**
    46 * Checks if the node is a React.createContext call
    57 * @param {ASTNode} node - The AST node being checked.
    6  * @returns {Boolean} - True if node is a React.createContext call, false if not.
     8 * @returns {boolean} - True if node is a React.createContext call, false if not.
    79 */
    810module.exports = function isCreateContext(node) {
    911  if (
    1012    node.init
    11     && node.init.type === 'CallExpression'
    1213    && node.init.callee
    13     && node.init.callee.name === 'createContext'
    1414  ) {
    15     return true;
    16   }
     15    if (
     16      astUtil.isCallExpression(node.init)
     17      && node.init.callee.name === 'createContext'
     18    ) {
     19      return true;
     20    }
    1721
    18   if (
    19     node.init
    20     && node.init.callee
    21     && node.init.callee.type === 'MemberExpression'
    22     && node.init.callee.property
    23     && node.init.callee.property.name === 'createContext'
    24   ) {
    25     return true;
     22    if (
     23      node.init.callee.type === 'MemberExpression'
     24      && node.init.callee.property
     25      && node.init.callee.property.name === 'createContext'
     26    ) {
     27      return true;
     28    }
    2629  }
    2730
    … …  
    3033    && node.expression.type === 'AssignmentExpression'
    3134    && node.expression.operator === '='
    32     && node.expression.right.type === 'CallExpression'
     35    && astUtil.isCallExpression(node.expression.right)
    3336    && node.expression.right.callee
    34     && node.expression.right.callee.name === 'createContext'
    3537  ) {
    36     return true;
    37   }
     38    const right = node.expression.right;
    3839
    39   if (
    40     node.expression
    41     && node.expression.type === 'AssignmentExpression'
    42     && node.expression.operator === '='
    43     && node.expression.right.type === 'CallExpression'
    44     && node.expression.right.callee
    45     && node.expression.right.callee.type === 'MemberExpression'
    46     && node.expression.right.callee.property
    47     && node.expression.right.callee.property.name === 'createContext'
    48   ) {
    49     return true;
     40    if (right.callee.name === 'createContext') {
     41      return true;
     42    }
     43
     44    if (
     45      right.callee.type === 'MemberExpression'
     46      && right.callee.property
     47      && right.callee.property.name === 'createContext'
     48    ) {
     49      return true;
     50    }
    5051  }
    5152

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/isCreateElement.js

    rd565449 r0c6b92a  
    1111*/
    1212module.exports = function isCreateElement(context, node) {
     13  if (!node.callee) {
     14    return false;
     15  }
     16
    1317  if (
    14     node.callee
    15     && node.callee.type === 'MemberExpression'
     18    node.callee.type === 'MemberExpression'
    1619    && node.callee.property.name === 'createElement'
    1720    && node.callee.object
    … …  
    2225
    2326  if (
    24     node
    25     && node.callee
    26     && node.callee.name === 'createElement'
     27    node.callee.name === 'createElement'
    2728    && isDestructuredFromPragmaImport(context, node, 'createElement')
    2829  ) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/isDestructuredFromPragmaImport.js

    rd565449 r0c6b92a  
    11'use strict';
    22
     3const astUtil = require('./ast');
    34const pragmaUtil = require('./pragma');
    45const variableUtil = require('./variable');
    … …  
    2324        if (
    2425          latestDef.node.init.type === 'MemberExpression'
    25               && latestDef.node.init.object.type === 'Identifier'
    26               && latestDef.node.init.object.name === pragma
     26          && latestDef.node.init.object.type === 'Identifier'
     27          && latestDef.node.init.object.name === pragma
    2728        ) {
    2829          return true;
    … …  
    3132        if (
    3233          latestDef.node.init.type === 'Identifier'
    33               && latestDef.node.init.name === pragma
     34          && latestDef.node.init.name === pragma
    3435        ) {
    3536          return true;
    … …  
    4041
    4142        // get "require('react')" from: "{variable} = require('react')"
    42         if (latestDef.node.init.type === 'CallExpression') {
     43        if (astUtil.isCallExpression(latestDef.node.init)) {
    4344          requireExpression = latestDef.node.init;
    4445        }
    … …  
    4647        if (
    4748          !requireExpression
    48               && latestDef.node.init.type === 'MemberExpression'
    49               && latestDef.node.init.object.type === 'CallExpression'
     49          && latestDef.node.init.type === 'MemberExpression'
     50          && astUtil.isCallExpression(latestDef.node.init.object)
    5051        ) {
    5152          requireExpression = latestDef.node.init.object;
    … …  
    5556        if (
    5657          requireExpression
    57               && requireExpression.callee
    58               && requireExpression.callee.name === 'require'
    59               && requireExpression.arguments[0]
    60               && requireExpression.arguments[0].value === pragma.toLocaleLowerCase()
     58          && requireExpression.callee
     59          && requireExpression.callee.name === 'require'
     60          && requireExpression.arguments[0]
     61          && requireExpression.arguments[0].value === pragma.toLocaleLowerCase()
    6162        ) {
    6263          return true;
    … …  
    6970      if (
    7071        latestDef.parent
    71             && latestDef.parent.type === 'ImportDeclaration'
    72             && latestDef.parent.source.value === pragma.toLocaleLowerCase()
     72        && latestDef.parent.type === 'ImportDeclaration'
     73        && latestDef.parent.source.value === pragma.toLocaleLowerCase()
    7374      ) {
    7475        return true;

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/isFirstLetterCapitalized.js

    rd565449 r0c6b92a  
    33/**
    44 * Check if the first letter of a string is capitalized.
    5  * @param {String} word String to check
    6  * @returns {Boolean} True if first letter is capitalized.
     5 * @param {string} word String to check
     6 * @returns {boolean} True if first letter is capitalized.
    77 */
    8 function isFirstLetterCapitalized(word) {
     8module.exports = function isFirstLetterCapitalized(word) {
    99  if (!word) {
    1010    return false;
    … …  
    1212  const firstLetter = word.replace(/^_+/, '').charAt(0);
    1313  return firstLetter.toUpperCase() === firstLetter;
    14 }
    15 
    16 module.exports = isFirstLetterCapitalized;
     14};

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

    rd565449 r0c6b92a  
    7777/**
    7878 * Check if value has only whitespaces
    79  * @param {string} value
     79 * @param {unknown} value
    8080 * @returns {boolean}
    8181 */
    … …  
    8989 * @param {Context} context The context of `ASTNode`.
    9090 * @param {ASTNode} ASTnode The AST node being checked
    91  * @param {Boolean} [strict] If true, in a ternary condition the node must return JSX in both cases
    92  * @param {Boolean} [ignoreNull] If true, null return values will be ignored
    93  * @returns {Boolean} True if the node is returning JSX or null, false if not
     91 * @param {boolean} [strict] If true, in a ternary condition the node must return JSX in both cases
     92 * @param {boolean} [ignoreNull] If true, null return values will be ignored
     93 * @returns {boolean} True if the node is returning JSX or null, false if not
    9494 */
    9595function isReturningJSX(context, ASTnode, strict, ignoreNull) {
    … …  
    146146 * @param {ASTNode} ASTnode The AST node being checked
    147147 * @param {Context} context The context of `ASTNode`.
    148  * @returns {Boolean} True if the node is returning only null values
     148 * @returns {boolean} True if the node is returning only null values
    149149 */
    150150function isReturningOnlyNull(ASTnode, context) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/log.js

    rd565449 r0c6b92a  
    33/**
    44 * Logs out a message if there is no format option set.
    5  * @param {String} message - Message to log.
     5 * @param {string} message - Message to log.
    66 */
    77function log(message) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/makeNoMethodSetStateRule.js

    rd565449 r0c6b92a  
    4545}
    4646
     47// eslint-disable-next-line valid-jsdoc
     48/**
     49 * @param {string} methodName
     50 * @param {(context: import('eslint').Rule.RuleContext) => boolean} [shouldCheckUnsafeCb]
     51 * @returns {import('eslint').Rule.RuleModule}
     52 */
    4753module.exports = function makeNoMethodSetStateRule(methodName, shouldCheckUnsafeCb) {
    4854  return {
    … …  
    9197            callee.type !== 'MemberExpression'
    9298            || callee.object.type !== 'ThisExpression'
     99            || !('name' in callee.property)
    93100            || callee.property.name !== 'setState'
    94101          ) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/pragma.js

    rd565449 r0c6b92a  
    6363
    6464  if (!JS_IDENTIFIER_REGEX.test(pragma)) {
    65     throw new Error(`React pragma ${pragma} is not a valid identifier`);
     65    console.warn(`React pragma ${pragma} is not a valid identifier`);
     66    return 'React';
    6667  }
    6768  return pragma;

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/propTypes.js

    rd565449 r0c6b92a  
    2424 * Check if node is function type.
    2525 * @param {ASTNode} node
    26  * @returns {Boolean}
     26 * @returns {boolean}
    2727 */
    2828function isFunctionType(node) {
    … …  
    3838 *
    3939 * @param {ASTNode} node  the AST node being checked.
    40  * @returns {Boolean} True if the node is a class with generic prop types, false if not.
     40 * @returns {boolean} True if the node is a class with generic prop types, false if not.
    4141 */
    4242function isSuperTypeParameterPropsDeclaration(node) {
    4343  if (node && (node.type === 'ClassDeclaration' || node.type === 'ClassExpression')) {
    44     if (node.superTypeParameters && node.superTypeParameters.params.length > 0) {
     44    const parameters = propsUtil.getSuperTypeArguments(node);
     45    if (parameters && parameters.params.length > 0) {
    4546      return true;
    4647    }
    … …  
    7778 * Checks if a node is inside a class body.
    7879 *
    79  * @param {ASTNode} node  the AST node being checked.
    80  * @returns {Boolean} True if the node has a ClassBody ancestor, false if not.
     80 * @param {ASTNode} node the AST node being checked.
     81 * @returns {boolean} True if the node has a ClassBody ancestor, false if not.
    8182 */
    8283function isInsideClassBody(node) {
    … …  
    153154  /**
    154155   * Checks if prop should be validated by plugin-react-proptypes
    155    * @param {String} validator Name of validator to check.
    156    * @returns {Boolean} True if validator should be checked by custom validator.
     156   * @param {string} validator Name of validator to check.
     157   * @returns {boolean} True if validator should be checked by custom validator.
    157158   */
    158159  function hasCustomValidator(validator) {
    … …  
    173174      let containsUnresolvedObjectTypeSpread = false;
    174175      let containsSpread = false;
    175       const containsIndexers = Boolean(annotation.indexers && annotation.indexers.length);
     176      const containsIndexers = !!annotation.indexers && annotation.indexers.length > 0;
    176177      const shapeTypeDefinition = {
    177178        type: 'shape',
    … …  
    268269   * The representation is used to verify nested used properties.
    269270   * @param {ASTNode} annotation Type annotation for the props class property.
    270    * @param {String} parentName
     271   * @param {string} parentName
    271272   * @param {Set<ASTNode>} [seen]
    272273   * @return {Object} The representation of the declaration, empty object means
    … …  
    297298   * @param {ASTNode} propTypes
    298299   * @param {Object} declaredPropTypes
    299    * @returns {Boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
     300   * @returns {boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
    300301   */
    301302  function declarePropTypesForObjectTypeAnnotation(propTypes, declaredPropTypes) {
    … …  
    335336   * @param {ASTNode} propTypes
    336337   * @param {Object} declaredPropTypes
    337    * @returns {Boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
     338   * @returns {boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
    338339   */
    339340  function declarePropTypesForIntersectionTypeAnnotation(propTypes, declaredPropTypes) {
    … …  
    428429      && value.type === 'MemberExpression'
    429430      && value.property
    430       && value.property.name
    431431      && value.property.name === 'isRequired'
    432432    ) {
    … …  
    448448    // Verify PropTypes that are functions
    449449    if (
    450       value
    451       && value.type === 'CallExpression'
     450      astUtil.isCallExpression(value)
    452451      && value.callee
    453452      && value.callee.property
    … …  
    498497          if (
    499498            !argument.elements
    500             || !argument.elements.length
     499            || argument.elements.length === 0
    501500          ) {
    502501            // Invalid proptype or cannot analyse statically
    … …  
    577576  function filterInterfaceOrAliasByName(node, typeName) {
    578577    return (
    579       (node.id && node.id.name === typeName)
    580       || (node.declaration && node.declaration.id && node.declaration.id.name === typeName)
     578      node.id
     579      && node.id.name === typeName
     580    ) || (
     581      node.declaration
     582      && node.declaration.id
     583      && node.declaration.id.name === typeName
    581584    );
    582585  }
    … …  
    638641        const leftMostName = getLeftMostTypeName(node.typeName);
    639642        const shouldTraverseTypeParams = genericReactTypesImport.has(leftMostName);
    640         const nodeTypeParams = node.typeParameters;
    641         if (shouldTraverseTypeParams && nodeTypeParams && nodeTypeParams.length !== 0) {
     643        const nodeTypeArguments = propsUtil.getTypeArguments(node);
     644        if (shouldTraverseTypeParams && nodeTypeArguments && nodeTypeArguments.length !== 0) {
    642645          // All react Generic types are derived from:
    643646          // type PropsWithChildren<P> = P & { children?: ReactNode | undefined }
    … …  
    661664            leftMostName !== rightMostName ? rightMostName : importedName
    662665          ];
    663           const nextNode = nodeTypeParams.params[idx];
     666          const nextNode = nodeTypeArguments.params[idx];
    664667          this.visitTSNode(nextNode);
    665668          return;
    … …  
    696699      const declarations = flatMap(
    697700        candidateTypes,
    698         (type) => type.declarations || (type.declaration && type.declaration.declarations) || type.declaration);
     701        (type) => (
     702          type.declarations
     703          || (
     704            type.declaration
     705            && type.declaration.declarations
     706          )
     707          || type.declaration
     708        )
     709      );
    699710
    700711      // we tried to find either an interface or a type with the TypeReference name
    … …  
    750761    convertReturnTypeToPropTypes(node, rootNode) {
    751762      // ReturnType<T> should always have one parameter
    752       const nodeTypeParams = node.typeParameters;
    753       if (nodeTypeParams) {
    754         if (nodeTypeParams.params.length === 1) {
    755           let returnType = nodeTypeParams.params[0];
     763      const nodeTypeArguments = propsUtil.getTypeArguments(node);
     764      if (nodeTypeArguments) {
     765        if (nodeTypeArguments.params.length === 1) {
     766          let returnType = nodeTypeArguments.params[0];
    756767          // This line is trying to handle typescript-eslint-parser
    757768          // typescript-eslint-parser TSTypeQuery is wrapped by TSTypeReference
    … …  
    784795                    case 'ObjectExpression':
    785796                      iterateProperties(context, res.properties, (key, value, propNode) => {
    786                         if (propNode && propNode.argument && propNode.argument.type === 'CallExpression') {
    787                           const propNodeTypeParams = propNode.argument.typeParameters;
    788                           if (propNodeTypeParams) {
    789                             this.visitTSNode(propNodeTypeParams);
     797                        if (propNode && astUtil.isCallExpression(propNode.argument)) {
     798                          const propNodeTypeArguments = propsUtil.getTypeArguments(propNode.argument);
     799                          if (propNodeTypeArguments) {
     800                            this.visitTSNode(propNodeTypeArguments);
    790801                          } else {
    791802                            // Ignore this CallExpression return value since it doesn't have any typeParameters to let us know it's types.
    … …  
    807818                      break;
    808819                    case 'CallExpression':
    809                       if (res.typeParameters) {
    810                         this.visitTSNode(res.typeParameters);
     820                      if (propsUtil.getTypeArguments(res)) {
     821                        this.visitTSNode(propsUtil.getTypeArguments(res));
    811822                      } else {
    812823                        // Ignore this CallExpression return value since it doesn't have any typeParameters to let us know it's types.
    … …  
    9931004      case 'GenericTypeAnnotation':
    9941005        if (propTypes.id.name === '$ReadOnly') {
    995           const propTypeParams = propTypes.typeParameters;
     1006          const propTypeArguments = propsUtil.getTypeArguments(propTypes);
    9961007          ignorePropsValidation = declarePropTypesForObjectTypeAnnotation(
    997             propTypeParams.params[0],
     1008            propTypeArguments.params[0],
    9981009            declaredPropTypes
    9991010          );
    … …  
    10321043    }
    10331044
     1045    let propTypesArguments = null;
     1046    if (node.parent) {
     1047      propTypesArguments = propsUtil.getTypeArguments(node.parent);
     1048    }
     1049
    10341050    if (
    10351051      node.parent
    10361052      && node.parent.callee
    1037       && node.parent.typeParameters
    1038       && node.parent.typeParameters.params
     1053      && propTypesArguments
     1054      && propTypesArguments.params
    10391055      && (
    10401056        node.parent.callee.name === 'forwardRef' || (
    … …  
    10461062      )
    10471063    ) {
    1048       const propTypesParams = node.parent.typeParameters;
    10491064      const declaredPropTypes = {};
    1050       const obj = new DeclarePropTypesForTSTypeAnnotation(propTypesParams.params[1], declaredPropTypes, rootNode);
     1065      const obj = new DeclarePropTypesForTSTypeAnnotation(propTypesArguments.params[1], declaredPropTypes, rootNode);
    10511066      components.set(node, {
    10521067        declaredPropTypes: obj.declaredPropTypes,
    … …  
    10941109        annotation
    10951110        && annotation.type !== 'TSTypeReference'
    1096         && annotation.typeParameters == null
     1111        && propsUtil.getTypeArguments(annotation) == null
    10971112      ) {
    10981113        return;
    … …  
    11061121
    11071122  /**
    1108    * Resolve the type annotation for a given class declaration node with superTypeParameters.
     1123   * Resolve the type annotation for a given class declaration node.
    11091124   *
    11101125   * @param {ASTNode} node The annotation or a node containing the type annotation.
    … …  
    11131128  function resolveSuperParameterPropsType(node) {
    11141129    let propsParameterPosition;
     1130    const parameters = propsUtil.getSuperTypeArguments(node);
     1131
    11151132    try {
    11161133      // Flow <=0.52 had 3 required TypedParameters of which the second one is the Props.
    … …  
    11191136    } catch (e) {
    11201137      // In case there is no flow version defined, we can safely assume that when there are 3 Props we are dealing with version <= 0.52
    1121       propsParameterPosition = node.superTypeParameters.params.length <= 2 ? 0 : 1;
    1122     }
    1123 
    1124     let annotation = node.superTypeParameters.params[propsParameterPosition];
     1138      propsParameterPosition = parameters.params.length <= 2 ? 0 : 1;
     1139    }
     1140
     1141    let annotation = parameters.params[propsParameterPosition];
    11251142    while (annotation && (annotation.type === 'TypeAnnotation' || annotation.type === 'NullableTypeAnnotation')) {
    11261143      annotation = annotation.typeAnnotation;
    … …  
    11361153   * Checks if we are declaring a `props` class property with a flow type annotation.
    11371154   * @param {ASTNode} node The AST node being checked.
    1138    * @returns {Boolean} True if the node is a type annotated props declaration, false if not.
     1155   * @returns {boolean} True if the node is a type annotated props declaration, false if not.
    11391156   */
    11401157  function isAnnotatedClassPropsDeclaration(node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/propTypesSort.js

    rd565449 r0c6b92a  
    1717 *
    1818 * @param {ASTNode} node the node to check.
    19  * @returns {String} The name of the node.
     19 * @returns {string} The name of the node.
    2020 */
    2121function getValueName(node) {
    22   return node.type === 'Property' && node.value.property && node.value.property.name;
     22  return node.type === 'Property'
     23    && node.value.property
     24    && node.value.property.name;
    2325}
    2426
    … …  
    2729 *
    2830 * @param {ASTNode} node the prop to check.
    29  * @returns {Boolean} true if the prop is required.
     31 * @returns {boolean} true if the prop is required.
    3032 */
    3133function isRequiredProp(node) {
    … …  
    3638 * Checks if the proptype is a callback by checking if it starts with 'on'.
    3739 *
    38  * @param {String} propName the name of the proptype to check.
    39  * @returns {Boolean} true if the proptype is a callback.
     40 * @param {string} propName the name of the proptype to check.
     41 * @returns {boolean} true if the proptype is a callback.
    4042 */
    4143function isCallbackPropName(propName) {
    … …  
    4749 *
    4850 * @param {ASTNode} node the prop to check.
    49  * @returns {Boolean} true if the prop is PropTypes.shape.
     51 * @returns {boolean} true if the prop is PropTypes.shape.
    5052 */
    5153function isShapeProp(node) {
    52   return Boolean(
    53     node && node.callee && node.callee.property && node.callee.property.name === 'shape'
     54  return !!(
     55    node
     56    && node.callee
     57    && node.callee.property
     58    && node.callee.property.name === 'shape'
    5459  );
    5560}
    … …  
    6267 */
    6368function getShapeProperties(node) {
    64   return node.arguments && node.arguments[0] && node.arguments[0].properties;
     69  return node.arguments
     70    && node.arguments[0]
     71    && node.arguments[0].properties;
    6572}
    6673
    … …  
    7178 * @param {ASTNode} b the second element to compare.
    7279 * @param {Context} context The context of the two nodes.
    73  * @param {Boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
    74  * @param {Boolean=} requiredFirst whether or not to sort required elements first.
    75  * @param {Boolean=} callbacksLast whether or not to sort callbacks after everything else.
    76  * @param {Boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
    77  * @returns {Number} the sort order of the two elements.
     80 * @param {boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
     81 * @param {boolean=} requiredFirst whether or not to sort required elements first.
     82 * @param {boolean=} callbacksLast whether or not to sort callbacks after everything else.
     83 * @param {boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
     84 * @returns {number} the sort order of the two elements.
    7885 */
    7986function sorter(a, b, context, ignoreCase, requiredFirst, callbacksLast, noSortAlphabetically) {
    … …  
    122129 * @param {Fixer} fixer the first element to compare.
    123130 * @param {Array} declarations The context of the two nodes.
    124  * @param {Boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
    125  * @param {Boolean=} requiredFirst whether or not to sort required elements first.
    126  * @param {Boolean=} callbacksLast whether or not to sort callbacks after everything else.
    127  * @param {Boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
    128  * @param {Boolean=} sortShapeProp whether or not to sort propTypes defined in PropTypes.shape.
    129  * @param {Boolean=} checkTypes whether or not sorting of prop type definitions are checked.
     131 * @param {boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
     132 * @param {boolean=} requiredFirst whether or not to sort required elements first.
     133 * @param {boolean=} callbacksLast whether or not to sort callbacks after everything else.
     134 * @param {boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
     135 * @param {boolean=} sortShapeProp whether or not to sort propTypes defined in PropTypes.shape.
     136 * @param {boolean=} checkTypes whether or not sorting of prop type definitions are checked.
    130137 * @returns {Object|*|{range, text}} the sort order of the two elements.
    131138 */
    … …  
    221228module.exports = {
    222229  fixPropTypesSort,
     230  isCallbackPropName,
     231  isRequiredProp,
     232  isShapeProp,
    223233};

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/props.js

    rd565449 r0c6b92a  
    1010 * Checks if the Identifier node passed in looks like a propTypes declaration.
    1111 * @param {ASTNode} node The node to check. Must be an Identifier node.
    12  * @returns {Boolean} `true` if the node is a propTypes declaration, `false` if not
     12 * @returns {boolean} `true` if the node is a propTypes declaration, `false` if not
    1313 */
    1414function isPropTypesDeclaration(node) {
    … …  
    2525 * Checks if the node passed in looks like a contextTypes declaration.
    2626 * @param {ASTNode} node The node to check.
    27  * @returns {Boolean} `true` if the node is a contextTypes declaration, `false` if not
     27 * @returns {boolean} `true` if the node is a contextTypes declaration, `false` if not
    2828 */
    2929function isContextTypesDeclaration(node) {
    … …  
    4040 * Checks if the node passed in looks like a contextType declaration.
    4141 * @param {ASTNode} node The node to check.
    42  * @returns {Boolean} `true` if the node is a contextType declaration, `false` if not
     42 * @returns {boolean} `true` if the node is a contextType declaration, `false` if not
    4343 */
    4444function isContextTypeDeclaration(node) {
    … …  
    4949 * Checks if the node passed in looks like a childContextTypes declaration.
    5050 * @param {ASTNode} node The node to check.
    51  * @returns {Boolean} `true` if the node is a childContextTypes declaration, `false` if not
     51 * @returns {boolean} `true` if the node is a childContextTypes declaration, `false` if not
    5252 */
    5353function isChildContextTypesDeclaration(node) {
    … …  
    5858 * Checks if the Identifier node passed in looks like a defaultProps declaration.
    5959 * @param {ASTNode} node The node to check. Must be an Identifier node.
    60  * @returns {Boolean} `true` if the node is a defaultProps declaration, `false` if not
     60 * @returns {boolean} `true` if the node is a defaultProps declaration, `false` if not
    6161 */
    6262function isDefaultPropsDeclaration(node) {
    … …  
    6868 * Checks if we are declaring a display name
    6969 * @param {ASTNode} node The AST node being checked.
    70  * @returns {Boolean} True if we are declaring a display name, false if not.
     70 * @returns {boolean} True if we are declaring a display name, false if not.
    7171 */
    7272function isDisplayNameDeclaration(node) {
    … …  
    8787 * Checks if the PropTypes MemberExpression node passed in declares a required propType.
    8888 * @param {ASTNode} propTypeExpression node to check. Must be a `PropTypes` MemberExpression.
    89  * @returns {Boolean} `true` if this PropType is required, `false` if not.
     89 * @returns {boolean} `true` if this PropType is required, `false` if not.
    9090 */
    9191function isRequiredPropType(propTypeExpression) {
    92   return propTypeExpression.type === 'MemberExpression' && propTypeExpression.property.name === 'isRequired';
     92  return propTypeExpression.type === 'MemberExpression'
     93    && propTypeExpression.property.name === 'isRequired';
     94}
     95
     96/**
     97 * Returns the type arguments of a node or type parameters if type arguments are not available.
     98 * @param {ASTNode} node The node to get the type arguments from.
     99 * @returns {ASTNode} The type arguments or type parameters of the node.
     100 */
     101function getTypeArguments(node) {
     102  if ('typeArguments' in node) {
     103    return node.typeArguments;
     104  }
     105  return node.typeParameters;
     106}
     107
     108/**
     109 * Returns the super type arguments of a node or super type parameters if type arguments are not available.
     110 * @param {ASTNode} node The node to get the super type arguments from.
     111 * @returns {ASTNode} The super type arguments or parameters of the node.
     112 */
     113function getSuperTypeArguments(node) {
     114  if ('superTypeArguments' in node) {
     115    return node.superTypeArguments;
     116  }
     117  return node.superTypeParameters;
    93118}
    94119
    … …  
    101126  isDisplayNameDeclaration,
    102127  isRequiredPropType,
     128  getTypeArguments,
     129  getSuperTypeArguments,
    103130};

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/usedPropTypes.js

    rd565449 r0c6b92a  
    6767 * Checks if the string is one of `props`, `nextProps`, or `prevProps`
    6868 * @param {string} name The AST node being checked.
    69  * @returns {Boolean} True if the prop name matches
     69 * @returns {boolean} True if the prop name matches
    7070 */
    7171function isCommonVariableNameForProps(name) {
    … …  
    7676 * Checks if the component must be validated
    7777 * @param {Object} component The component to process
    78  * @returns {Boolean} True if the component must be validated, false if not.
     78 * @returns {boolean} True if the component must be validated, false if not.
    7979 */
    8080function mustBeValidated(component) {
    … …  
    111111 * @param {ASTNode} node The AST node being checked.
    112112 * @param {boolean} checkAsyncSafeLifeCycles
    113  * @return {Boolean} True if the node is a lifecycle method
     113 * @return {boolean} True if the node is a lifecycle method
    114114 */
    115115function isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles) {
    116   const nodeKeyName = (node.key || /** @type {ASTNode} */ ({})).name;
    117 
    118   if (node.kind === 'constructor') {
    119     return true;
    120   }
    121   if (LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
    122     return true;
    123   }
    124   if (checkAsyncSafeLifeCycles && ASYNC_SAFE_LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
    125     return true;
     116  if (node.key) {
     117    if (node.kind === 'constructor') {
     118      return true;
     119    }
     120
     121    const nodeKeyName = node.key.name;
     122
     123    if (typeof nodeKeyName !== 'string') {
     124      return false;
     125    }
     126
     127    if (LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
     128      return true;
     129    }
     130    if (checkAsyncSafeLifeCycles && ASYNC_SAFE_LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
     131      return true;
     132    }
    126133  }
    127134
    … …  
    134141 * @param {ASTNode} node The AST node being checked.
    135142 * @param {boolean} checkAsyncSafeLifeCycles
    136  * @return {Boolean} True if the node is inside a lifecycle method
     143 * @return {boolean} True if the node is inside a lifecycle method
    137144 */
    138145function isInLifeCycleMethod(node, checkAsyncSafeLifeCycles) {
    139   if ((node.type === 'MethodDefinition' || node.type === 'Property') && isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles)) {
     146  if (
     147    (node.type === 'MethodDefinition' || node.type === 'Property')
     148    && isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles)
     149  ) {
    140150    return true;
    141151  }
    … …  
    154164 */
    155165function isSetStateUpdater(node) {
    156   const unwrappedParentCalleeNode = node.parent && node.parent.type === 'CallExpression'
     166  const unwrappedParentCalleeNode = astUtil.isCallExpression(node.parent)
    157167    && ast.unwrapTSAsExpression(node.parent.callee);
    158168
    … …  
    171181  while (scope) {
    172182    const unwrappedParentCalleeNode = scope.block
    173       && scope.block.parent
    174       && scope.block.parent.type === 'CallExpression'
     183      && astUtil.isCallExpression(scope.block.parent)
    175184      && ast.unwrapTSAsExpression(scope.block.parent.callee);
    176185    if (
    … …  
    215224 * @param {object} context
    216225 * @param {ASTNode} node The AST node being marked.
    217  * @returns {Boolean} True if the prop has spread operator, false if not.
     226 * @returns {boolean} True if the prop has spread operator, false if not.
    218227 */
    219228function hasSpreadOperator(context, node) {

  • imaps-frontend/node_modules/eslint-plugin-react/lib/util/variable.js

    rd565449 r0c6b92a  
    1212 * @param {Array} variables The variables list.
    1313 * @param {string} name The name of the variable to search.
    14  * @returns {Boolean} True if the variable was found, false if not.
     14 * @returns {boolean} True if the variable was found, false if not.
    1515 */
    1616function findVariable(variables, name) {
Note: See TracChangeset for help on using the changeset viewer.