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 committed 2025-11-18 10:23:55 -03:00
1 parent 20129a1ac7
commit ac4f232e5e
787 files changed
+82341 -121690

No files matched your search

+97 -239
View File
@@ -4,263 +4,121 @@
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
const TYPE_NODES = new Set([
"TSTypeReference",
"TSInterfaceHeritage",
"TSClassImplements",
"TSTypeQuery",
"TSQualifiedName",
]);
const GLOBAL_OBJECTS = new Set(["globalThis", "self", "window"]);
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
const arrayOfGlobals = {
type: "array",
items: {
oneOf: [
{
type: "string",
},
{
type: "object",
properties: {
name: { type: "string" },
message: { type: "string" },
},
required: ["name"],
additionalProperties: false,
},
],
},
uniqueItems: true,
minItems: 0,
};
/** @type {import('../types').Rule.RuleModule} */
/** @type {import('../shared/types').Rule} */
module.exports = {
meta: {
dialects: ["javascript", "typescript"],
language: "javascript",
type: "suggestion",
meta: {
type: "suggestion",
docs: {
description: "Disallow specified global variables",
recommended: false,
url: "https://eslint.org/docs/latest/rules/no-restricted-globals",
},
docs: {
description: "Disallow specified global variables",
recommended: false,
url: "https://eslint.org/docs/latest/rules/no-restricted-globals"
},
schema: {
anyOf: [
arrayOfGlobals,
{
type: "array",
items: [
{
type: "object",
properties: {
globals: arrayOfGlobals,
checkGlobalObject: {
type: "boolean",
},
globalObjects: {
type: "array",
items: {
type: "string",
},
uniqueItems: true,
},
},
required: ["globals"],
additionalProperties: false,
},
],
additionalItems: false,
},
],
},
schema: {
type: "array",
items: {
oneOf: [
{
type: "string"
},
{
type: "object",
properties: {
name: { type: "string" },
message: { type: "string" }
},
required: ["name"],
additionalProperties: false
}
]
},
uniqueItems: true,
minItems: 0
},
messages: {
defaultMessage: "Unexpected use of '{{name}}'.",
// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
customMessage: "Unexpected use of '{{name}}'. {{customMessage}}",
},
},
messages: {
defaultMessage: "Unexpected use of '{{name}}'.",
// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
customMessage: "Unexpected use of '{{name}}'. {{customMessage}}"
}
},
create(context) {
const { sourceCode, options } = context;
create(context) {
const isGlobalsObject =
typeof options[0] === "object" &&
Object.hasOwn(options[0], "globals");
const sourceCode = context.sourceCode;
const restrictedGlobals = isGlobalsObject
? options[0].globals
: options;
const checkGlobalObject = isGlobalsObject
? options[0].checkGlobalObject
: false;
const userGlobalObjects = isGlobalsObject
? options[0].globalObjects || []
: [];
// If no globals are restricted, we don't need to do anything
if (context.options.length === 0) {
return {};
}
const globalObjects = new Set([
...GLOBAL_OBJECTS,
...userGlobalObjects,
]);
const restrictedGlobalMessages = context.options.reduce((memo, option) => {
if (typeof option === "string") {
memo[option] = null;
} else {
memo[option.name] = option.message;
}
// If no globals are restricted, we don't need to do anything
if (restrictedGlobals.length === 0) {
return {};
}
return memo;
}, {});
const restrictedGlobalMessages = restrictedGlobals.reduce(
(memo, option) => {
if (typeof option === "string") {
memo[option] = null;
} else {
memo[option.name] = option.message;
}
/**
* Report a variable to be used as a restricted global.
* @param {Reference} reference the variable reference
* @returns {void}
* @private
*/
function reportReference(reference) {
const name = reference.identifier.name,
customMessage = restrictedGlobalMessages[name],
messageId = customMessage
? "customMessage"
: "defaultMessage";
return memo;
},
{},
);
context.report({
node: reference.identifier,
messageId,
data: {
name,
customMessage
}
});
}
/**
* Report a variable to be used as a restricted global.
* @param {Reference} reference the variable reference
* @returns {void}
* @private
*/
function reportReference(reference) {
const name = reference.identifier.name,
customMessage = restrictedGlobalMessages[name],
messageId = customMessage ? "customMessage" : "defaultMessage";
/**
* Check if the given name is a restricted global name.
* @param {string} name name of a variable
* @returns {boolean} whether the variable is a restricted global or not
* @private
*/
function isRestricted(name) {
return Object.prototype.hasOwnProperty.call(restrictedGlobalMessages, name);
}
context.report({
node: reference.identifier,
messageId,
data: {
name,
customMessage,
},
});
}
return {
Program(node) {
const scope = sourceCode.getScope(node);
/**
* Check if the given name is a restricted global name.
* @param {string} name name of a variable
* @returns {boolean} whether the variable is a restricted global or not
* @private
*/
function isRestricted(name) {
return Object.hasOwn(restrictedGlobalMessages, name);
}
// Report variables declared elsewhere (ex: variables defined as "global" by eslint)
scope.variables.forEach(variable => {
if (!variable.defs.length && isRestricted(variable.name)) {
variable.references.forEach(reportReference);
}
});
/**
* Check if the given reference occurs within a TypeScript type context.
* @param {Reference} reference The variable reference to check.
* @returns {boolean} Whether the reference is in a type context.
* @private
*/
function isInTypeContext(reference) {
const parent = reference.identifier.parent;
// Report variables not declared at all
scope.through.forEach(reference => {
if (isRestricted(reference.identifier.name)) {
reportReference(reference);
}
});
return TYPE_NODES.has(parent.type);
}
return {
Program(node) {
const scope = sourceCode.getScope(node);
// Report variables declared elsewhere (ex: variables defined as "global" by eslint)
scope.variables.forEach(variable => {
if (!variable.defs.length && isRestricted(variable.name)) {
variable.references.forEach(reference => {
if (!isInTypeContext(reference)) {
reportReference(reference);
}
});
}
});
// Report variables not declared at all
scope.through.forEach(reference => {
if (
isRestricted(reference.identifier.name) &&
!isInTypeContext(reference)
) {
reportReference(reference);
}
});
},
"Program:exit"(node) {
if (!checkGlobalObject) {
return;
}
const globalScope = sourceCode.getScope(node);
globalObjects.forEach(globalObjectName => {
const variable = astUtils.getVariableByName(
globalScope,
globalObjectName,
);
if (!variable) {
return;
}
variable.references.forEach(reference => {
const identifier = reference.identifier;
let parent = identifier.parent;
// To detect code like `window.window.Promise`.
while (
astUtils.isSpecificMemberAccess(
parent,
null,
globalObjectName,
)
) {
parent = parent.parent;
}
const propertyName =
astUtils.getStaticPropertyName(parent);
if (propertyName && isRestricted(propertyName)) {
const customMessage =
restrictedGlobalMessages[propertyName];
const messageId = customMessage
? "customMessage"
: "defaultMessage";
context.report({
node: parent.property,
messageId,
data: {
name: propertyName,
customMessage,
},
});
}
});
});
},
};
},
}
};
}
};