paramNames: formatSet()

in packages/eui/scripts/eslint-plugin/i18n.js [363:509]
124 lines of code
21 McCabe index (conditional complexity)

                  paramNames: formatSet(paramsSet),
                },
              });
            }
          } else {
            // single token, single param should be a matching identifier
            const param = renderProp.params[0];
            const tokenName = getExpectedParamNameFromToken(
              attributes.token.value
            );
            const paramName = param.name;

            if (tokenName !== paramName) {
              context.report({
                node,
                loc: node.loc,
                messageId: 'tokenNamesNotUsedInRenderProp',
                data: { tokenNames: tokenName, paramNames: paramName },
              });
            }
          }
        }

        // debugger;
      },
      CallExpression(node) {
        // Only process calls to useEuiI18n
        if (
          !node.callee ||
          node.callee.type !== 'Identifier' ||
          node.callee.name !== 'useEuiI18n'
        )
          return;

        const nodeArgs = node.arguments;

        const isSingleToken = nodeArgs[0].type === 'Literal';

        // validate argument types
        if (isSingleToken) {
          // default must be either a Literal of an ArrowFunctionExpression
          const defaultArg = nodeArgs[1];
          const isLiteral = defaultArg.type === 'Literal';
          const isArrowExpression =
            defaultArg.type === 'ArrowFunctionExpression';
          if (!isLiteral && !isArrowExpression) {
            context.report({
              node,
              loc: defaultArg.loc,
              messageId: 'invalidDefaultType',
              data: { type: defaultArg.type },
            });
            return;
          }
        } else {
          const tokensArg = nodeArgs[0];
          const defaultsArg = nodeArgs[1];

          // tokens must be an array of Literals
          if (tokensArg.type !== 'ArrayExpression') {
            context.report({
              node,
              loc: tokensArg.loc,
              messageId: 'invalidTokensType',
              data: { type: tokensArg.type },
            });
            return;
          }

          for (let i = 0; i < tokensArg.elements.length; i++) {
            const tokenNode = tokensArg.elements[i];
            if (
              tokenNode.type !== 'Literal' ||
              typeof tokenNode.value !== 'string'
            ) {
              context.report({
                node,
                loc: tokenNode.loc,
                messageId: 'invalidTokensType',
                data: { type: tokenNode.type },
              });
              return;
            }
          }

          // defaults must be an array of either Literals or ArrowFunctionExpressions
          if (defaultsArg.type !== 'ArrayExpression') {
            context.report({
              node,
              loc: defaultsArg.loc,
              messageId: 'invalidDefaultsType',
              data: { type: defaultsArg.type },
            });
            return;
          }

          for (let i = 0; i < defaultsArg.elements.length; i++) {
            const defaultNode = defaultsArg.elements[i];
            if (
              defaultNode.type !== 'Literal' ||
              typeof defaultNode.value !== 'string'
            ) {
              context.report({
                node,
                loc: defaultNode.loc,
                messageId: 'invalidDefaultsType',
                data: { type: defaultNode.type },
              });
              return;
            }
          }
        }

        if (isSingleToken) {
          const tokenArgument = nodeArgs[0];
          const defaultArgument = nodeArgs[1];
          const valuesArgument = nodeArgs[2];

          // validate token format
          const tokenParts = tokenArgument.value.split('.');
          if (
            tokenParts.length <= 1 ||
            tokenParts[0] !== expectedTokenNamespace
          ) {
            context.report({
              node,
              loc: tokenArgument.loc,
              messageId: 'invalidToken',
              data: {
                tokenValue: tokenArgument.value,
                tokenNamespace: expectedTokenNamespace,
              },
            });
          }

          // validate default string interpolation matches values
          const valueNames = getDefinedValues(valuesArgument);

          if (defaultArgument.type === 'Literal') {
            // default is a string literal
            const expectedNames = getExpectedValueNames(defaultArgument.value);
            if (areSetsEqual(expectedNames, valueNames) === false) {
              context.report({
                node,
                loc: valuesArgument.loc,
                messageId: 'mismatchedValues',
                data: {