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
+151
-175
@@ -24,20 +24,20 @@ const RELATIONAL_OPERATORS = ["in", "instanceof"];
|
||||
const TERNARY_OPERATOR = ["?:"];
|
||||
const COALESCE_OPERATOR = ["??"];
|
||||
const ALL_OPERATORS = [].concat(
|
||||
ARITHMETIC_OPERATORS,
|
||||
BITWISE_OPERATORS,
|
||||
COMPARISON_OPERATORS,
|
||||
LOGICAL_OPERATORS,
|
||||
RELATIONAL_OPERATORS,
|
||||
TERNARY_OPERATOR,
|
||||
COALESCE_OPERATOR,
|
||||
ARITHMETIC_OPERATORS,
|
||||
BITWISE_OPERATORS,
|
||||
COMPARISON_OPERATORS,
|
||||
LOGICAL_OPERATORS,
|
||||
RELATIONAL_OPERATORS,
|
||||
TERNARY_OPERATOR,
|
||||
COALESCE_OPERATOR
|
||||
);
|
||||
const DEFAULT_GROUPS = [
|
||||
ARITHMETIC_OPERATORS,
|
||||
BITWISE_OPERATORS,
|
||||
COMPARISON_OPERATORS,
|
||||
LOGICAL_OPERATORS,
|
||||
RELATIONAL_OPERATORS,
|
||||
ARITHMETIC_OPERATORS,
|
||||
BITWISE_OPERATORS,
|
||||
COMPARISON_OPERATORS,
|
||||
LOGICAL_OPERATORS,
|
||||
RELATIONAL_OPERATORS
|
||||
];
|
||||
const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
|
||||
|
||||
@@ -47,14 +47,14 @@ const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
|
||||
* @returns {Object} Normalized option object.
|
||||
*/
|
||||
function normalizeOptions(options = {}) {
|
||||
const hasGroups = options.groups && options.groups.length > 0;
|
||||
const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
|
||||
const allowSamePrecedence = options.allowSamePrecedence !== false;
|
||||
const hasGroups = options.groups && options.groups.length > 0;
|
||||
const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
|
||||
const allowSamePrecedence = options.allowSamePrecedence !== false;
|
||||
|
||||
return {
|
||||
groups,
|
||||
allowSamePrecedence,
|
||||
};
|
||||
return {
|
||||
groups,
|
||||
allowSamePrecedence
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -65,7 +65,7 @@ function normalizeOptions(options = {}) {
|
||||
* @returns {boolean} `true` if such group existed.
|
||||
*/
|
||||
function includesBothInAGroup(groups, left, right) {
|
||||
return groups.some(group => group.includes(left) && group.includes(right));
|
||||
return groups.some(group => group.includes(left) && group.includes(right));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -76,178 +76,154 @@ function includesBothInAGroup(groups, left, right) {
|
||||
* @returns {ASTNode} node the appropriate node(left or test).
|
||||
*/
|
||||
function getChildNode(node) {
|
||||
return node.type === "ConditionalExpression" ? node.test : node.left;
|
||||
return node.type === "ConditionalExpression" ? node.test : node.left;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin",
|
||||
url: "https://eslint.style",
|
||||
},
|
||||
rule: {
|
||||
name: "no-mixed-operators",
|
||||
url: "https://eslint.style/rules/no-mixed-operators",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "suggestion",
|
||||
meta: {
|
||||
deprecated: true,
|
||||
replacedBy: [],
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow mixed binary operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-mixed-operators",
|
||||
},
|
||||
docs: {
|
||||
description: "Disallow mixed binary operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-mixed-operators"
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
groups: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "array",
|
||||
items: { enum: ALL_OPERATORS },
|
||||
minItems: 2,
|
||||
uniqueItems: true,
|
||||
},
|
||||
uniqueItems: true,
|
||||
},
|
||||
allowSamePrecedence: {
|
||||
type: "boolean",
|
||||
default: true,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
groups: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "array",
|
||||
items: { enum: ALL_OPERATORS },
|
||||
minItems: 2,
|
||||
uniqueItems: true
|
||||
},
|
||||
uniqueItems: true
|
||||
},
|
||||
allowSamePrecedence: {
|
||||
type: "boolean",
|
||||
default: true
|
||||
}
|
||||
},
|
||||
additionalProperties: false
|
||||
}
|
||||
],
|
||||
|
||||
messages: {
|
||||
unexpectedMixedOperator:
|
||||
"Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations.",
|
||||
},
|
||||
},
|
||||
messages: {
|
||||
unexpectedMixedOperator: "Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations."
|
||||
}
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const options = normalizeOptions(context.options[0]);
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const options = normalizeOptions(context.options[0]);
|
||||
|
||||
/**
|
||||
* Checks whether a given node should be ignored by options or not.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {boolean} `true` if the node should be ignored.
|
||||
*/
|
||||
function shouldIgnore(node) {
|
||||
const a = node;
|
||||
const b = node.parent;
|
||||
/**
|
||||
* Checks whether a given node should be ignored by options or not.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {boolean} `true` if the node should be ignored.
|
||||
*/
|
||||
function shouldIgnore(node) {
|
||||
const a = node;
|
||||
const b = node.parent;
|
||||
|
||||
return (
|
||||
!includesBothInAGroup(
|
||||
options.groups,
|
||||
a.operator,
|
||||
b.type === "ConditionalExpression" ? "?:" : b.operator,
|
||||
) ||
|
||||
(options.allowSamePrecedence &&
|
||||
astUtils.getPrecedence(a) === astUtils.getPrecedence(b))
|
||||
);
|
||||
}
|
||||
return (
|
||||
!includesBothInAGroup(options.groups, a.operator, b.type === "ConditionalExpression" ? "?:" : b.operator) ||
|
||||
(
|
||||
options.allowSamePrecedence &&
|
||||
astUtils.getPrecedence(a) === astUtils.getPrecedence(b)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the operator of a given node is mixed with parent
|
||||
* node's operator or not.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {boolean} `true` if the node was mixed.
|
||||
*/
|
||||
function isMixedWithParent(node) {
|
||||
return (
|
||||
node.operator !== node.parent.operator &&
|
||||
!astUtils.isParenthesised(sourceCode, node)
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Checks whether the operator of a given node is mixed with parent
|
||||
* node's operator or not.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {boolean} `true` if the node was mixed.
|
||||
*/
|
||||
function isMixedWithParent(node) {
|
||||
|
||||
/**
|
||||
* Gets the operator token of a given node.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node.
|
||||
* @returns {Token} The operator token of the node.
|
||||
*/
|
||||
function getOperatorToken(node) {
|
||||
return sourceCode.getTokenAfter(
|
||||
getChildNode(node),
|
||||
astUtils.isNotClosingParenToken,
|
||||
);
|
||||
}
|
||||
return (
|
||||
node.operator !== node.parent.operator &&
|
||||
!astUtils.isParenthesised(sourceCode, node)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports both the operator of a given node and the operator of the
|
||||
* parent node.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {void}
|
||||
*/
|
||||
function reportBothOperators(node) {
|
||||
const parent = node.parent;
|
||||
const left = getChildNode(parent) === node ? node : parent;
|
||||
const right = getChildNode(parent) !== node ? node : parent;
|
||||
const data = {
|
||||
leftOperator: left.operator || "?:",
|
||||
rightOperator: right.operator || "?:",
|
||||
};
|
||||
/**
|
||||
* Gets the operator token of a given node.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node.
|
||||
* @returns {Token} The operator token of the node.
|
||||
*/
|
||||
function getOperatorToken(node) {
|
||||
return sourceCode.getTokenAfter(getChildNode(node), astUtils.isNotClosingParenToken);
|
||||
}
|
||||
|
||||
context.report({
|
||||
node: left,
|
||||
loc: getOperatorToken(left).loc,
|
||||
messageId: "unexpectedMixedOperator",
|
||||
data,
|
||||
});
|
||||
context.report({
|
||||
node: right,
|
||||
loc: getOperatorToken(right).loc,
|
||||
messageId: "unexpectedMixedOperator",
|
||||
data,
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Reports both the operator of a given node and the operator of the
|
||||
* parent node.
|
||||
* @param {ASTNode} node A node to check. This is a BinaryExpression
|
||||
* node or a LogicalExpression node. This parent node is one of
|
||||
* them, too.
|
||||
* @returns {void}
|
||||
*/
|
||||
function reportBothOperators(node) {
|
||||
const parent = node.parent;
|
||||
const left = (getChildNode(parent) === node) ? node : parent;
|
||||
const right = (getChildNode(parent) !== node) ? node : parent;
|
||||
const data = {
|
||||
leftOperator: left.operator || "?:",
|
||||
rightOperator: right.operator || "?:"
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks between the operator of this node and the operator of the
|
||||
* parent node.
|
||||
* @param {ASTNode} node A node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function check(node) {
|
||||
if (
|
||||
TARGET_NODE_TYPE.test(node.parent.type) &&
|
||||
isMixedWithParent(node) &&
|
||||
!shouldIgnore(node)
|
||||
) {
|
||||
reportBothOperators(node);
|
||||
}
|
||||
}
|
||||
context.report({
|
||||
node: left,
|
||||
loc: getOperatorToken(left).loc,
|
||||
messageId: "unexpectedMixedOperator",
|
||||
data
|
||||
});
|
||||
context.report({
|
||||
node: right,
|
||||
loc: getOperatorToken(right).loc,
|
||||
messageId: "unexpectedMixedOperator",
|
||||
data
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
BinaryExpression: check,
|
||||
LogicalExpression: check,
|
||||
};
|
||||
},
|
||||
/**
|
||||
* Checks between the operator of this node and the operator of the
|
||||
* parent node.
|
||||
* @param {ASTNode} node A node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function check(node) {
|
||||
if (
|
||||
TARGET_NODE_TYPE.test(node.parent.type) &&
|
||||
isMixedWithParent(node) &&
|
||||
!shouldIgnore(node)
|
||||
) {
|
||||
reportBothOperators(node);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
BinaryExpression: check,
|
||||
LogicalExpression: check
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user