build: update npm install command to use --legacy-peer-deps
This change modifies the build scripts to use --legacy-peer-deps flag when installing npm dependencies to resolve potential peer dependency conflicts during the build process. The change is applied to both bash (build.sh) and batch (build.bat) build scripts.
This commit is contained in:
Luiz Costa
+139
-200
@@ -22,7 +22,7 @@ const astUtils = require("./utils/ast-utils");
|
||||
* shorthand form.
|
||||
*/
|
||||
function isCommutativeOperatorWithShorthand(operator) {
|
||||
return ["*", "&", "^", "|"].includes(operator);
|
||||
return ["*", "&", "^", "|"].includes(operator);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -33,7 +33,7 @@ function isCommutativeOperatorWithShorthand(operator) {
|
||||
* a shorthand form.
|
||||
*/
|
||||
function isNonCommutativeOperatorWithShorthand(operator) {
|
||||
return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].includes(operator);
|
||||
return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].includes(operator);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
@@ -47,224 +47,163 @@ function isNonCommutativeOperatorWithShorthand(operator) {
|
||||
* @returns {boolean} `true` if the node can be fixed
|
||||
*/
|
||||
function canBeFixed(node) {
|
||||
return (
|
||||
node.type === "Identifier" ||
|
||||
(node.type === "MemberExpression" &&
|
||||
(node.object.type === "Identifier" ||
|
||||
node.object.type === "ThisExpression") &&
|
||||
(!node.computed || node.property.type === "Literal"))
|
||||
);
|
||||
return (
|
||||
node.type === "Identifier" ||
|
||||
(
|
||||
node.type === "MemberExpression" &&
|
||||
(node.object.type === "Identifier" || node.object.type === "ThisExpression") &&
|
||||
(!node.computed || node.property.type === "Literal")
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: ["always"],
|
||||
docs: {
|
||||
description: "Require or disallow assignment operator shorthand where possible",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/operator-assignment"
|
||||
},
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Require or disallow assignment operator shorthand where possible",
|
||||
recommended: false,
|
||||
frozen: true,
|
||||
url: "https://eslint.org/docs/latest/rules/operator-assignment",
|
||||
},
|
||||
schema: [
|
||||
{
|
||||
enum: ["always", "never"]
|
||||
}
|
||||
],
|
||||
|
||||
schema: [
|
||||
{
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
],
|
||||
fixable: "code",
|
||||
messages: {
|
||||
replaced: "Assignment (=) can be replaced with operator assignment ({{operator}}).",
|
||||
unexpected: "Unexpected operator assignment ({{operator}}) shorthand."
|
||||
}
|
||||
},
|
||||
|
||||
fixable: "code",
|
||||
messages: {
|
||||
replaced:
|
||||
"Assignment (=) can be replaced with operator assignment ({{operator}}).",
|
||||
unexpected:
|
||||
"Unexpected operator assignment ({{operator}}) shorthand.",
|
||||
},
|
||||
},
|
||||
create(context) {
|
||||
|
||||
create(context) {
|
||||
const never = context.options[0] === "never";
|
||||
const sourceCode = context.sourceCode;
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Returns the operator token of an AssignmentExpression or BinaryExpression
|
||||
* @param {ASTNode} node An AssignmentExpression or BinaryExpression node
|
||||
* @returns {Token} The operator token in the node
|
||||
*/
|
||||
function getOperatorToken(node) {
|
||||
return sourceCode.getFirstTokenBetween(
|
||||
node.left,
|
||||
node.right,
|
||||
token => token.value === node.operator,
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Returns the operator token of an AssignmentExpression or BinaryExpression
|
||||
* @param {ASTNode} node An AssignmentExpression or BinaryExpression node
|
||||
* @returns {Token} The operator token in the node
|
||||
*/
|
||||
function getOperatorToken(node) {
|
||||
return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that an assignment uses the shorthand form where possible.
|
||||
* @param {ASTNode} node An AssignmentExpression node.
|
||||
* @returns {void}
|
||||
*/
|
||||
function verify(node) {
|
||||
if (
|
||||
node.operator !== "=" ||
|
||||
node.right.type !== "BinaryExpression"
|
||||
) {
|
||||
return;
|
||||
}
|
||||
/**
|
||||
* Ensures that an assignment uses the shorthand form where possible.
|
||||
* @param {ASTNode} node An AssignmentExpression node.
|
||||
* @returns {void}
|
||||
*/
|
||||
function verify(node) {
|
||||
if (node.operator !== "=" || node.right.type !== "BinaryExpression") {
|
||||
return;
|
||||
}
|
||||
|
||||
const left = node.left;
|
||||
const expr = node.right;
|
||||
const operator = expr.operator;
|
||||
const left = node.left;
|
||||
const expr = node.right;
|
||||
const operator = expr.operator;
|
||||
|
||||
if (
|
||||
isCommutativeOperatorWithShorthand(operator) ||
|
||||
isNonCommutativeOperatorWithShorthand(operator)
|
||||
) {
|
||||
const replacementOperator = `${operator}=`;
|
||||
if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {
|
||||
const replacementOperator = `${operator}=`;
|
||||
|
||||
if (astUtils.isSameReference(left, expr.left, true)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "replaced",
|
||||
data: { operator: replacementOperator },
|
||||
fix(fixer) {
|
||||
if (canBeFixed(left) && canBeFixed(expr.left)) {
|
||||
const equalsToken = getOperatorToken(node);
|
||||
const operatorToken = getOperatorToken(expr);
|
||||
const leftText = sourceCode
|
||||
.getText()
|
||||
.slice(node.range[0], equalsToken.range[0]);
|
||||
const rightText = sourceCode
|
||||
.getText()
|
||||
.slice(
|
||||
operatorToken.range[1],
|
||||
node.right.range[1],
|
||||
);
|
||||
if (astUtils.isSameReference(left, expr.left, true)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "replaced",
|
||||
data: { operator: replacementOperator },
|
||||
fix(fixer) {
|
||||
if (canBeFixed(left) && canBeFixed(expr.left)) {
|
||||
const equalsToken = getOperatorToken(node);
|
||||
const operatorToken = getOperatorToken(expr);
|
||||
const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);
|
||||
const rightText = sourceCode.getText().slice(operatorToken.range[1], node.right.range[1]);
|
||||
|
||||
// Check for comments that would be removed.
|
||||
if (
|
||||
sourceCode.commentsExistBetween(
|
||||
equalsToken,
|
||||
operatorToken,
|
||||
)
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
// Check for comments that would be removed.
|
||||
if (sourceCode.commentsExistBetween(equalsToken, operatorToken)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return fixer.replaceText(
|
||||
node,
|
||||
`${leftText}${replacementOperator}${rightText}`,
|
||||
);
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
} else if (
|
||||
astUtils.isSameReference(left, expr.right, true) &&
|
||||
isCommutativeOperatorWithShorthand(operator)
|
||||
) {
|
||||
/*
|
||||
* This case can't be fixed safely.
|
||||
* If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would
|
||||
* change the execution order of the valueOf() functions.
|
||||
*/
|
||||
context.report({
|
||||
node,
|
||||
messageId: "replaced",
|
||||
data: { operator: replacementOperator },
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return fixer.replaceText(node, `${leftText}${replacementOperator}${rightText}`);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
});
|
||||
} else if (astUtils.isSameReference(left, expr.right, true) && isCommutativeOperatorWithShorthand(operator)) {
|
||||
|
||||
/**
|
||||
* Warns if an assignment expression uses operator assignment shorthand.
|
||||
* @param {ASTNode} node An AssignmentExpression node.
|
||||
* @returns {void}
|
||||
*/
|
||||
function prohibit(node) {
|
||||
if (
|
||||
node.operator !== "=" &&
|
||||
!astUtils.isLogicalAssignmentOperator(node.operator)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpected",
|
||||
data: { operator: node.operator },
|
||||
fix(fixer) {
|
||||
if (canBeFixed(node.left)) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const operatorToken = getOperatorToken(node);
|
||||
const leftText = sourceCode
|
||||
.getText()
|
||||
.slice(node.range[0], operatorToken.range[0]);
|
||||
const newOperator = node.operator.slice(0, -1);
|
||||
let rightText;
|
||||
/*
|
||||
* This case can't be fixed safely.
|
||||
* If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would
|
||||
* change the execution order of the valueOf() functions.
|
||||
*/
|
||||
context.report({
|
||||
node,
|
||||
messageId: "replaced",
|
||||
data: { operator: replacementOperator }
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check for comments that would be duplicated.
|
||||
if (
|
||||
sourceCode.commentsExistBetween(
|
||||
firstToken,
|
||||
operatorToken,
|
||||
)
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
* Warns if an assignment expression uses operator assignment shorthand.
|
||||
* @param {ASTNode} node An AssignmentExpression node.
|
||||
* @returns {void}
|
||||
*/
|
||||
function prohibit(node) {
|
||||
if (node.operator !== "=" && !astUtils.isLogicalAssignmentOperator(node.operator)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpected",
|
||||
data: { operator: node.operator },
|
||||
fix(fixer) {
|
||||
if (canBeFixed(node.left)) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const operatorToken = getOperatorToken(node);
|
||||
const leftText = sourceCode.getText().slice(node.range[0], operatorToken.range[0]);
|
||||
const newOperator = node.operator.slice(0, -1);
|
||||
let rightText;
|
||||
|
||||
// If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.
|
||||
if (
|
||||
astUtils.getPrecedence(node.right) <=
|
||||
astUtils.getPrecedence({
|
||||
type: "BinaryExpression",
|
||||
operator: newOperator,
|
||||
}) &&
|
||||
!astUtils.isParenthesised(
|
||||
sourceCode,
|
||||
node.right,
|
||||
)
|
||||
) {
|
||||
rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
|
||||
} else {
|
||||
const tokenAfterOperator =
|
||||
sourceCode.getTokenAfter(operatorToken, {
|
||||
includeComments: true,
|
||||
});
|
||||
let rightTextPrefix = "";
|
||||
// Check for comments that would be duplicated.
|
||||
if (sourceCode.commentsExistBetween(firstToken, operatorToken)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (
|
||||
operatorToken.range[1] ===
|
||||
tokenAfterOperator.range[0] &&
|
||||
!astUtils.canTokensBeAdjacent(
|
||||
{
|
||||
type: "Punctuator",
|
||||
value: newOperator,
|
||||
},
|
||||
tokenAfterOperator,
|
||||
)
|
||||
) {
|
||||
rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
|
||||
}
|
||||
// If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.
|
||||
if (
|
||||
astUtils.getPrecedence(node.right) <= astUtils.getPrecedence({ type: "BinaryExpression", operator: newOperator }) &&
|
||||
!astUtils.isParenthesised(sourceCode, node.right)
|
||||
) {
|
||||
rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
|
||||
} else {
|
||||
const tokenAfterOperator = sourceCode.getTokenAfter(operatorToken, { includeComments: true });
|
||||
let rightTextPrefix = "";
|
||||
|
||||
rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
|
||||
}
|
||||
if (
|
||||
operatorToken.range[1] === tokenAfterOperator.range[0] &&
|
||||
!astUtils.canTokensBeAdjacent({ type: "Punctuator", value: newOperator }, tokenAfterOperator)
|
||||
) {
|
||||
rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
|
||||
}
|
||||
|
||||
return fixer.replaceText(
|
||||
node,
|
||||
`${leftText}= ${leftText}${newOperator}${rightText}`,
|
||||
);
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
|
||||
}
|
||||
|
||||
return {
|
||||
AssignmentExpression: !never ? verify : prohibit,
|
||||
};
|
||||
},
|
||||
return fixer.replaceText(node, `${leftText}= ${leftText}${newOperator}${rightText}`);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
AssignmentExpression: context.options[0] !== "never" ? verify : prohibit
|
||||
};
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user