304 lines
9.9 KiB
JavaScript
304 lines
9.9 KiB
JavaScript
/**
|
||
* @fileoverview Report missing `key` props in iterators/collection literals.
|
||
* @author Ben Mosher
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
const hasProp = require('jsx-ast-utils/hasProp');
|
||
const propName = require('jsx-ast-utils/propName');
|
||
const values = require('object.values');
|
||
const docsUrl = require('../util/docsUrl');
|
||
const pragmaUtil = require('../util/pragma');
|
||
const report = require('../util/report');
|
||
const astUtil = require('../util/ast');
|
||
const getText = require('../util/eslint').getText;
|
||
|
||
// ------------------------------------------------------------------------------
|
||
// Rule Definition
|
||
// ------------------------------------------------------------------------------
|
||
|
||
const defaultOptions = {
|
||
checkFragmentShorthand: false,
|
||
checkKeyMustBeforeSpread: false,
|
||
warnOnDuplicates: false,
|
||
};
|
||
|
||
const messages = {
|
||
missingIterKey: 'Missing "key" prop for element in iterator',
|
||
missingIterKeyUsePrag: 'Missing "key" prop for element in iterator. Shorthand fragment syntax does not support providing keys. Use {{reactPrag}}.{{fragPrag}} instead',
|
||
missingArrayKey: 'Missing "key" prop for element in array',
|
||
missingArrayKeyUsePrag: 'Missing "key" prop for element in array. Shorthand fragment syntax does not support providing keys. Use {{reactPrag}}.{{fragPrag}} instead',
|
||
keyBeforeSpread: '`key` prop must be placed before any `{...spread}, to avoid conflicting with React’s new JSX transform: https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html`',
|
||
nonUniqueKeys: '`key` prop must be unique',
|
||
};
|
||
|
||
/** @type {import('eslint').Rule.RuleModule} */
|
||
module.exports = {
|
||
meta: {
|
||
docs: {
|
||
description: 'Disallow missing `key` props in iterators/collection literals',
|
||
category: 'Possible Errors',
|
||
recommended: true,
|
||
url: docsUrl('jsx-key'),
|
||
},
|
||
|
||
messages,
|
||
|
||
schema: [{
|
||
type: 'object',
|
||
properties: {
|
||
checkFragmentShorthand: {
|
||
type: 'boolean',
|
||
default: defaultOptions.checkFragmentShorthand,
|
||
},
|
||
checkKeyMustBeforeSpread: {
|
||
type: 'boolean',
|
||
default: defaultOptions.checkKeyMustBeforeSpread,
|
||
},
|
||
warnOnDuplicates: {
|
||
type: 'boolean',
|
||
default: defaultOptions.warnOnDuplicates,
|
||
},
|
||
},
|
||
additionalProperties: false,
|
||
}],
|
||
},
|
||
|
||
create(context) {
|
||
const options = Object.assign({}, defaultOptions, context.options[0]);
|
||
const checkFragmentShorthand = options.checkFragmentShorthand;
|
||
const checkKeyMustBeforeSpread = options.checkKeyMustBeforeSpread;
|
||
const warnOnDuplicates = options.warnOnDuplicates;
|
||
const reactPragma = pragmaUtil.getFromContext(context);
|
||
const fragmentPragma = pragmaUtil.getFragmentFromContext(context);
|
||
|
||
function isKeyAfterSpread(attributes) {
|
||
let hasFoundSpread = false;
|
||
return attributes.some((attribute) => {
|
||
if (attribute.type === 'JSXSpreadAttribute') {
|
||
hasFoundSpread = true;
|
||
return false;
|
||
}
|
||
if (attribute.type !== 'JSXAttribute') {
|
||
return false;
|
||
}
|
||
return hasFoundSpread && propName(attribute) === 'key';
|
||
});
|
||
}
|
||
|
||
function checkIteratorElement(node) {
|
||
if (node.type === 'JSXElement') {
|
||
if (!hasProp(node.openingElement.attributes, 'key')) {
|
||
report(context, messages.missingIterKey, 'missingIterKey', { node });
|
||
} else {
|
||
const attrs = node.openingElement.attributes;
|
||
|
||
if (checkKeyMustBeforeSpread && isKeyAfterSpread(attrs)) {
|
||
report(context, messages.keyBeforeSpread, 'keyBeforeSpread', { node });
|
||
}
|
||
}
|
||
} else if (checkFragmentShorthand && node.type === 'JSXFragment') {
|
||
report(context, messages.missingIterKeyUsePrag, 'missingIterKeyUsePrag', {
|
||
node,
|
||
data: {
|
||
reactPrag: reactPragma,
|
||
fragPrag: fragmentPragma,
|
||
},
|
||
});
|
||
}
|
||
}
|
||
|
||
function getReturnStatements(node) {
|
||
const returnStatements = arguments[1] || [];
|
||
if (node.type === 'IfStatement') {
|
||
if (node.consequent) {
|
||
getReturnStatements(node.consequent, returnStatements);
|
||
}
|
||
if (node.alternate) {
|
||
getReturnStatements(node.alternate, returnStatements);
|
||
}
|
||
} else if (node.type === 'ReturnStatement') {
|
||
returnStatements.push(node);
|
||
} else if (Array.isArray(node.body)) {
|
||
node.body.forEach((item) => {
|
||
if (item.type === 'IfStatement') {
|
||
getReturnStatements(item, returnStatements);
|
||
}
|
||
|
||
if (item.type === 'ReturnStatement') {
|
||
returnStatements.push(item);
|
||
}
|
||
});
|
||
}
|
||
|
||
return returnStatements;
|
||
}
|
||
|
||
/**
|
||
* Checks if the given node is a function expression or arrow function,
|
||
* and checks if there is a missing key prop in return statement's arguments
|
||
* @param {ASTNode} node
|
||
*/
|
||
function checkFunctionsBlockStatement(node) {
|
||
if (astUtil.isFunctionLikeExpression(node)) {
|
||
if (node.body.type === 'BlockStatement') {
|
||
getReturnStatements(node.body)
|
||
.filter((returnStatement) => returnStatement && returnStatement.argument)
|
||
.forEach((returnStatement) => {
|
||
checkIteratorElement(returnStatement.argument);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Checks if the given node is an arrow function that has an JSX Element or JSX Fragment in its body,
|
||
* and the JSX is missing a key prop
|
||
* @param {ASTNode} node
|
||
*/
|
||
function checkArrowFunctionWithJSX(node) {
|
||
const isArrFn = node && node.type === 'ArrowFunctionExpression';
|
||
const shouldCheckNode = (n) => n && (n.type === 'JSXElement' || n.type === 'JSXFragment');
|
||
if (isArrFn && shouldCheckNode(node.body)) {
|
||
checkIteratorElement(node.body);
|
||
}
|
||
if (node.body.type === 'ConditionalExpression') {
|
||
if (shouldCheckNode(node.body.consequent)) {
|
||
checkIteratorElement(node.body.consequent);
|
||
}
|
||
if (shouldCheckNode(node.body.alternate)) {
|
||
checkIteratorElement(node.body.alternate);
|
||
}
|
||
} else if (node.body.type === 'LogicalExpression' && shouldCheckNode(node.body.right)) {
|
||
checkIteratorElement(node.body.right);
|
||
}
|
||
}
|
||
|
||
const childrenToArraySelector = `:matches(
|
||
CallExpression
|
||
[callee.object.object.name=${reactPragma}]
|
||
[callee.object.property.name=Children]
|
||
[callee.property.name=toArray],
|
||
CallExpression
|
||
[callee.object.name=Children]
|
||
[callee.property.name=toArray]
|
||
)`.replace(/\s/g, '');
|
||
let isWithinChildrenToArray = false;
|
||
|
||
const seen = new WeakSet();
|
||
|
||
return {
|
||
[childrenToArraySelector]() {
|
||
isWithinChildrenToArray = true;
|
||
},
|
||
|
||
[`${childrenToArraySelector}:exit`]() {
|
||
isWithinChildrenToArray = false;
|
||
},
|
||
|
||
'ArrayExpression, JSXElement > JSXElement'(node) {
|
||
if (isWithinChildrenToArray) {
|
||
return;
|
||
}
|
||
|
||
const jsx = (node.type === 'ArrayExpression' ? node.elements : node.parent.children).filter((x) => x && x.type === 'JSXElement');
|
||
if (jsx.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const map = {};
|
||
jsx.forEach((element) => {
|
||
const attrs = element.openingElement.attributes;
|
||
const keys = attrs.filter((x) => x.name && x.name.name === 'key');
|
||
|
||
if (keys.length === 0) {
|
||
if (node.type === 'ArrayExpression') {
|
||
report(context, messages.missingArrayKey, 'missingArrayKey', {
|
||
node: element,
|
||
});
|
||
}
|
||
} else {
|
||
keys.forEach((attr) => {
|
||
const value = getText(context, attr.value);
|
||
if (!map[value]) { map[value] = []; }
|
||
map[value].push(attr);
|
||
|
||
if (checkKeyMustBeforeSpread && isKeyAfterSpread(attrs)) {
|
||
report(context, messages.keyBeforeSpread, 'keyBeforeSpread', {
|
||
node: node.type === 'ArrayExpression' ? node : node.parent,
|
||
});
|
||
}
|
||
});
|
||
}
|
||
});
|
||
|
||
if (warnOnDuplicates) {
|
||
values(map).filter((v) => v.length > 1).forEach((v) => {
|
||
v.forEach((n) => {
|
||
if (!seen.has(n)) {
|
||
seen.add(n);
|
||
report(context, messages.nonUniqueKeys, 'nonUniqueKeys', {
|
||
node: n,
|
||
});
|
||
}
|
||
});
|
||
});
|
||
}
|
||
},
|
||
|
||
JSXFragment(node) {
|
||
if (!checkFragmentShorthand || isWithinChildrenToArray) {
|
||
return;
|
||
}
|
||
|
||
if (node.parent.type === 'ArrayExpression') {
|
||
report(context, messages.missingArrayKeyUsePrag, 'missingArrayKeyUsePrag', {
|
||
node,
|
||
data: {
|
||
reactPrag: reactPragma,
|
||
fragPrag: fragmentPragma,
|
||
},
|
||
});
|
||
}
|
||
},
|
||
|
||
// Array.prototype.map
|
||
// eslint-disable-next-line no-multi-str
|
||
'CallExpression[callee.type="MemberExpression"][callee.property.name="map"],\
|
||
CallExpression[callee.type="OptionalMemberExpression"][callee.property.name="map"],\
|
||
OptionalCallExpression[callee.type="MemberExpression"][callee.property.name="map"],\
|
||
OptionalCallExpression[callee.type="OptionalMemberExpression"][callee.property.name="map"]'(node) {
|
||
if (isWithinChildrenToArray) {
|
||
return;
|
||
}
|
||
|
||
const fn = node.arguments.length > 0 && node.arguments[0];
|
||
if (!fn || !astUtil.isFunctionLikeExpression(fn)) {
|
||
return;
|
||
}
|
||
|
||
checkArrowFunctionWithJSX(fn);
|
||
|
||
checkFunctionsBlockStatement(fn);
|
||
},
|
||
|
||
// Array.from
|
||
'CallExpression[callee.type="MemberExpression"][callee.property.name="from"]'(node) {
|
||
if (isWithinChildrenToArray) {
|
||
return;
|
||
}
|
||
|
||
const fn = node.arguments.length > 1 && node.arguments[1];
|
||
if (!astUtil.isFunctionLikeExpression(fn)) {
|
||
return;
|
||
}
|
||
|
||
checkArrowFunctionWithJSX(fn);
|
||
|
||
checkFunctionsBlockStatement(fn);
|
||
},
|
||
};
|
||
},
|
||
};
|