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
2025-11-18 10:23:55 -03:00
parent 20129a1ac7
commit ac4f232e5e
787 changed files with 82341 additions and 121690 deletions
+116 -157
View File
@@ -5,183 +5,142 @@
"use strict";
const ASSIGNMENT_NODES = new Set([
"AssignmentExpression",
"ForInStatement",
"ForOfStatement",
]);
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
/** @type {import('../shared/types').Rule} */
module.exports = {
meta: {
type: "suggestion",
meta: {
type: "suggestion",
defaultOptions: [
{
lexicalBindings: false,
},
],
docs: {
description: "Disallow declarations in the global scope",
recommended: false,
url: "https://eslint.org/docs/latest/rules/no-implicit-globals"
},
docs: {
description: "Disallow declarations in the global scope",
recommended: false,
url: "https://eslint.org/docs/latest/rules/no-implicit-globals",
},
schema: [{
type: "object",
properties: {
lexicalBindings: {
type: "boolean",
default: false
}
},
additionalProperties: false
}],
schema: [
{
type: "object",
properties: {
lexicalBindings: {
type: "boolean",
},
},
additionalProperties: false,
},
],
messages: {
globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
}
},
messages: {
globalNonLexicalBinding:
"Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
globalLexicalBinding:
"Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
globalVariableLeak:
"Global variable leak, declare the variable if it is intended to be local.",
assignmentToReadonlyGlobal:
"Unexpected assignment to read-only global variable.",
redeclarationOfReadonlyGlobal:
"Unexpected redeclaration of read-only global variable.",
},
},
create(context) {
create(context) {
const [{ lexicalBindings: checkLexicalBindings }] = context.options;
const sourceCode = context.sourceCode;
const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
const sourceCode = context.sourceCode;
/**
* Reports the node.
* @param {ASTNode} node Node to report.
* @param {string} messageId Id of the message to report.
* @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
* @returns {void}
*/
function report(node, messageId, kind) {
context.report({
node,
messageId,
data: {
kind,
},
});
}
/**
* Reports the node.
* @param {ASTNode} node Node to report.
* @param {string} messageId Id of the message to report.
* @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
* @returns {void}
*/
function report(node, messageId, kind) {
context.report({
node,
messageId,
data: {
kind
}
});
}
return {
Program(node) {
const scope = sourceCode.getScope(node);
return {
Program(node) {
const scope = sourceCode.getScope(node);
scope.variables.forEach(variable => {
// Only ESLint global variables have the `writable` key.
const isReadonlyEslintGlobalVariable =
variable.writeable === false;
const isWritableEslintGlobalVariable =
variable.writeable === true;
scope.variables.forEach(variable => {
if (isWritableEslintGlobalVariable) {
// Everything is allowed with writable ESLint global variables.
return;
}
// Only ESLint global variables have the `writable` key.
const isReadonlyEslintGlobalVariable = variable.writeable === false;
const isWritableEslintGlobalVariable = variable.writeable === true;
// Variables exported by "exported" block comments
if (variable.eslintExported) {
return;
}
if (isWritableEslintGlobalVariable) {
variable.defs.forEach(def => {
const defNode = def.node;
// Everything is allowed with writable ESLint global variables.
return;
}
if (
def.type === "FunctionName" ||
(def.type === "Variable" &&
def.parent.kind === "var")
) {
if (isReadonlyEslintGlobalVariable) {
report(
defNode,
"redeclarationOfReadonlyGlobal",
);
} else {
report(
defNode,
"globalNonLexicalBinding",
def.type === "FunctionName"
? "function"
: `'${def.parent.kind}'`,
);
}
}
// Variables exported by "exported" block comments
if (variable.eslintExported) {
return;
}
if (checkLexicalBindings) {
if (
def.type === "ClassName" ||
(def.type === "Variable" &&
(def.parent.kind === "let" ||
def.parent.kind === "const"))
) {
if (isReadonlyEslintGlobalVariable) {
report(
defNode,
"redeclarationOfReadonlyGlobal",
);
} else {
report(
defNode,
"globalLexicalBinding",
def.type === "ClassName"
? "class"
: `'${def.parent.kind}'`,
);
}
}
}
});
variable.defs.forEach(def => {
const defNode = def.node;
if (
isReadonlyEslintGlobalVariable &&
variable.defs.length === 0
) {
variable.references.forEach(reference => {
if (reference.isWrite() && !reference.isRead()) {
let assignmentParent =
reference.identifier.parent;
if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
if (isReadonlyEslintGlobalVariable) {
report(defNode, "redeclarationOfReadonlyGlobal");
} else {
report(
defNode,
"globalNonLexicalBinding",
def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`
);
}
}
while (
assignmentParent &&
!ASSIGNMENT_NODES.has(assignmentParent.type)
) {
assignmentParent = assignmentParent.parent;
}
if (checkLexicalBindings) {
if (def.type === "ClassName" ||
(def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const"))) {
if (isReadonlyEslintGlobalVariable) {
report(defNode, "redeclarationOfReadonlyGlobal");
} else {
report(
defNode,
"globalLexicalBinding",
def.type === "ClassName" ? "class" : `'${def.parent.kind}'`
);
}
}
}
});
});
report(
assignmentParent ?? reference.identifier,
"assignmentToReadonlyGlobal",
);
}
});
}
});
// Undeclared assigned variables.
scope.implicit.variables.forEach(variable => {
const scopeVariable = scope.set.get(variable.name);
let messageId;
// Undeclared assigned variables.
scope.implicit.variables.forEach(variable => {
// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
variable.defs.forEach(def => {
report(def.node, "globalVariableLeak");
});
});
},
};
},
if (scopeVariable) {
// ESLint global variable
if (scopeVariable.writeable) {
return;
}
messageId = "assignmentToReadonlyGlobal";
} else {
// Reference to an unknown variable, possible global leak.
messageId = "globalVariableLeak";
}
// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
variable.defs.forEach(def => {
report(def.node, messageId);
});
});
}
};
}
};