Add components
This commit is contained in:
418
slider/node_modules/eslint/lib/rules/arrow-body-style.js
generated
vendored
Normal file
418
slider/node_modules/eslint/lib/rules/arrow-body-style.js
generated
vendored
Normal file
@@ -0,0 +1,418 @@
|
||||
/**
|
||||
* @fileoverview Rule to require braces in arrow function body.
|
||||
* @author Alberto Rodríguez
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: ["as-needed"],
|
||||
|
||||
docs: {
|
||||
description: "Require braces around arrow function bodies",
|
||||
recommended: false,
|
||||
frozen: true,
|
||||
url: "https://eslint.org/docs/latest/rules/arrow-body-style",
|
||||
},
|
||||
|
||||
schema: {
|
||||
anyOf: [
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 1,
|
||||
},
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["as-needed"],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
requireReturnForObjectLiteral: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 2,
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
fixable: "code",
|
||||
|
||||
messages: {
|
||||
unexpectedOtherBlock:
|
||||
"Unexpected block statement surrounding arrow body.",
|
||||
unexpectedEmptyBlock:
|
||||
"Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.",
|
||||
unexpectedObjectBlock:
|
||||
"Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.",
|
||||
unexpectedSingleBlock:
|
||||
"Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.",
|
||||
expectedBlock: "Expected block statement surrounding arrow body.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const options = context.options;
|
||||
const always = options[0] === "always";
|
||||
const asNeeded = options[0] === "as-needed";
|
||||
const never = options[0] === "never";
|
||||
const requireReturnForObjectLiteral =
|
||||
options[1] && options[1].requireReturnForObjectLiteral;
|
||||
const sourceCode = context.sourceCode;
|
||||
let funcInfo = null;
|
||||
|
||||
/**
|
||||
* Checks whether the given node has ASI problem or not.
|
||||
* @param {Token} token The token to check.
|
||||
* @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.
|
||||
*/
|
||||
function hasASIProblem(token) {
|
||||
return (
|
||||
token &&
|
||||
token.type === "Punctuator" &&
|
||||
/^[([/`+-]/u.test(token.value)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the closing parenthesis by the given node.
|
||||
* @param {ASTNode} node first node after an opening parenthesis.
|
||||
* @returns {Token} The found closing parenthesis token.
|
||||
*/
|
||||
function findClosingParen(node) {
|
||||
let nodeToCheck = node;
|
||||
|
||||
while (!astUtils.isParenthesised(sourceCode, nodeToCheck)) {
|
||||
nodeToCheck = nodeToCheck.parent;
|
||||
}
|
||||
return sourceCode.getTokenAfter(nodeToCheck);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the node is inside of a for loop's init
|
||||
* @param {ASTNode} node node is inside for loop
|
||||
* @returns {boolean} `true` if the node is inside of a for loop, else `false`
|
||||
*/
|
||||
function isInsideForLoopInitializer(node) {
|
||||
if (node && node.parent) {
|
||||
if (
|
||||
node.parent.type === "ForStatement" &&
|
||||
node.parent.init === node
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
return isInsideForLoopInitializer(node.parent);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether a arrow function body needs braces
|
||||
* @param {ASTNode} node The arrow function node.
|
||||
* @returns {void}
|
||||
*/
|
||||
function validate(node) {
|
||||
const arrowBody = node.body;
|
||||
|
||||
if (arrowBody.type === "BlockStatement") {
|
||||
const blockBody = arrowBody.body;
|
||||
|
||||
if (blockBody.length !== 1 && !never) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
asNeeded &&
|
||||
requireReturnForObjectLiteral &&
|
||||
blockBody[0].type === "ReturnStatement" &&
|
||||
blockBody[0].argument &&
|
||||
blockBody[0].argument.type === "ObjectExpression"
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
never ||
|
||||
(asNeeded && blockBody[0].type === "ReturnStatement")
|
||||
) {
|
||||
let messageId;
|
||||
|
||||
if (blockBody.length === 0) {
|
||||
messageId = "unexpectedEmptyBlock";
|
||||
} else if (
|
||||
blockBody.length > 1 ||
|
||||
blockBody[0].type !== "ReturnStatement"
|
||||
) {
|
||||
messageId = "unexpectedOtherBlock";
|
||||
} else if (blockBody[0].argument === null) {
|
||||
messageId = "unexpectedSingleBlock";
|
||||
} else if (
|
||||
astUtils.isOpeningBraceToken(
|
||||
sourceCode.getFirstToken(blockBody[0], { skip: 1 }),
|
||||
)
|
||||
) {
|
||||
messageId = "unexpectedObjectBlock";
|
||||
} else {
|
||||
messageId = "unexpectedSingleBlock";
|
||||
}
|
||||
|
||||
context.report({
|
||||
node,
|
||||
loc: arrowBody.loc,
|
||||
messageId,
|
||||
fix(fixer) {
|
||||
const fixes = [];
|
||||
|
||||
if (
|
||||
blockBody.length !== 1 ||
|
||||
blockBody[0].type !== "ReturnStatement" ||
|
||||
!blockBody[0].argument ||
|
||||
hasASIProblem(
|
||||
sourceCode.getTokenAfter(arrowBody),
|
||||
)
|
||||
) {
|
||||
return fixes;
|
||||
}
|
||||
|
||||
const openingBrace =
|
||||
sourceCode.getFirstToken(arrowBody);
|
||||
const closingBrace =
|
||||
sourceCode.getLastToken(arrowBody);
|
||||
const firstValueToken = sourceCode.getFirstToken(
|
||||
blockBody[0],
|
||||
1,
|
||||
);
|
||||
const lastValueToken = sourceCode.getLastToken(
|
||||
blockBody[0],
|
||||
);
|
||||
const commentsExist =
|
||||
sourceCode.commentsExistBetween(
|
||||
openingBrace,
|
||||
firstValueToken,
|
||||
) ||
|
||||
sourceCode.commentsExistBetween(
|
||||
lastValueToken,
|
||||
closingBrace,
|
||||
);
|
||||
|
||||
/*
|
||||
* Remove tokens around the return value.
|
||||
* If comments don't exist, remove extra spaces as well.
|
||||
*/
|
||||
if (commentsExist) {
|
||||
fixes.push(
|
||||
fixer.remove(openingBrace),
|
||||
fixer.remove(closingBrace),
|
||||
fixer.remove(
|
||||
sourceCode.getTokenAfter(openingBrace),
|
||||
), // return keyword
|
||||
);
|
||||
} else {
|
||||
fixes.push(
|
||||
fixer.removeRange([
|
||||
openingBrace.range[0],
|
||||
firstValueToken.range[0],
|
||||
]),
|
||||
fixer.removeRange([
|
||||
lastValueToken.range[1],
|
||||
closingBrace.range[1],
|
||||
]),
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* If the first token of the return value is `{` or the return value is a sequence expression,
|
||||
* enclose the return value by parentheses to avoid syntax error.
|
||||
*/
|
||||
if (
|
||||
astUtils.isOpeningBraceToken(firstValueToken) ||
|
||||
blockBody[0].argument.type ===
|
||||
"SequenceExpression" ||
|
||||
(funcInfo.hasInOperator &&
|
||||
isInsideForLoopInitializer(node))
|
||||
) {
|
||||
if (
|
||||
!astUtils.isParenthesised(
|
||||
sourceCode,
|
||||
blockBody[0].argument,
|
||||
)
|
||||
) {
|
||||
fixes.push(
|
||||
fixer.insertTextBefore(
|
||||
firstValueToken,
|
||||
"(",
|
||||
),
|
||||
fixer.insertTextAfter(
|
||||
lastValueToken,
|
||||
")",
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the last token of the return statement is semicolon, remove it.
|
||||
* Non-block arrow body is an expression, not a statement.
|
||||
*/
|
||||
if (astUtils.isSemicolonToken(lastValueToken)) {
|
||||
fixes.push(fixer.remove(lastValueToken));
|
||||
}
|
||||
|
||||
return fixes;
|
||||
},
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (
|
||||
always ||
|
||||
(asNeeded &&
|
||||
requireReturnForObjectLiteral &&
|
||||
arrowBody.type === "ObjectExpression")
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
loc: arrowBody.loc,
|
||||
messageId: "expectedBlock",
|
||||
fix(fixer) {
|
||||
const fixes = [];
|
||||
const arrowToken = sourceCode.getTokenBefore(
|
||||
arrowBody,
|
||||
astUtils.isArrowToken,
|
||||
);
|
||||
const [
|
||||
firstTokenAfterArrow,
|
||||
secondTokenAfterArrow,
|
||||
] = sourceCode.getTokensAfter(arrowToken, {
|
||||
count: 2,
|
||||
});
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
|
||||
let parenthesisedObjectLiteral = null;
|
||||
|
||||
if (
|
||||
astUtils.isOpeningParenToken(
|
||||
firstTokenAfterArrow,
|
||||
) &&
|
||||
astUtils.isOpeningBraceToken(
|
||||
secondTokenAfterArrow,
|
||||
)
|
||||
) {
|
||||
const braceNode =
|
||||
sourceCode.getNodeByRangeIndex(
|
||||
secondTokenAfterArrow.range[0],
|
||||
);
|
||||
|
||||
if (braceNode.type === "ObjectExpression") {
|
||||
parenthesisedObjectLiteral = braceNode;
|
||||
}
|
||||
}
|
||||
|
||||
// If the value is object literal, remove parentheses which were forced by syntax.
|
||||
if (parenthesisedObjectLiteral) {
|
||||
const openingParenToken = firstTokenAfterArrow;
|
||||
const openingBraceToken = secondTokenAfterArrow;
|
||||
|
||||
if (
|
||||
astUtils.isTokenOnSameLine(
|
||||
openingParenToken,
|
||||
openingBraceToken,
|
||||
)
|
||||
) {
|
||||
fixes.push(
|
||||
fixer.replaceText(
|
||||
openingParenToken,
|
||||
"{return ",
|
||||
),
|
||||
);
|
||||
} else {
|
||||
// Avoid ASI
|
||||
fixes.push(
|
||||
fixer.replaceText(
|
||||
openingParenToken,
|
||||
"{",
|
||||
),
|
||||
fixer.insertTextBefore(
|
||||
openingBraceToken,
|
||||
"return ",
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
// Closing paren for the object doesn't have to be lastToken, e.g.: () => ({}).foo()
|
||||
fixes.push(
|
||||
fixer.remove(
|
||||
findClosingParen(
|
||||
parenthesisedObjectLiteral,
|
||||
),
|
||||
),
|
||||
);
|
||||
fixes.push(
|
||||
fixer.insertTextAfter(lastToken, "}"),
|
||||
);
|
||||
} else {
|
||||
fixes.push(
|
||||
fixer.insertTextBefore(
|
||||
firstTokenAfterArrow,
|
||||
"{return ",
|
||||
),
|
||||
);
|
||||
fixes.push(
|
||||
fixer.insertTextAfter(lastToken, "}"),
|
||||
);
|
||||
}
|
||||
|
||||
return fixes;
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
"BinaryExpression[operator='in']"() {
|
||||
let info = funcInfo;
|
||||
|
||||
while (info) {
|
||||
info.hasInOperator = true;
|
||||
info = info.upper;
|
||||
}
|
||||
},
|
||||
ArrowFunctionExpression() {
|
||||
funcInfo = {
|
||||
upper: funcInfo,
|
||||
hasInOperator: false,
|
||||
};
|
||||
},
|
||||
"ArrowFunctionExpression:exit"(node) {
|
||||
validate(node);
|
||||
funcInfo = funcInfo.upper;
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user