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
+197
-295
@@ -9,8 +9,7 @@
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const SENTINEL_TYPE =
|
||||
/^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
|
||||
const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
|
||||
const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
|
||||
|
||||
/**
|
||||
@@ -19,21 +18,21 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
|
||||
* @returns {Object} The parsed options.
|
||||
*/
|
||||
function parseOptions(options) {
|
||||
if (typeof options === "object" && options !== null) {
|
||||
return options;
|
||||
}
|
||||
let functions = true;
|
||||
let classes = true;
|
||||
let variables = true;
|
||||
let allowNamedExports = false;
|
||||
|
||||
const functions = typeof options === "string" ? options !== "nofunc" : true;
|
||||
if (typeof options === "string") {
|
||||
functions = (options !== "nofunc");
|
||||
} else if (typeof options === "object" && options !== null) {
|
||||
functions = options.functions !== false;
|
||||
classes = options.classes !== false;
|
||||
variables = options.variables !== false;
|
||||
allowNamedExports = !!options.allowNamedExports;
|
||||
}
|
||||
|
||||
return {
|
||||
functions,
|
||||
classes: true,
|
||||
variables: true,
|
||||
allowNamedExports: false,
|
||||
enums: true,
|
||||
typedefs: true,
|
||||
ignoreTypeReferences: true,
|
||||
};
|
||||
return { functions, classes, variables, allowNamedExports };
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -43,7 +42,7 @@ function parseOptions(options) {
|
||||
* @returns {boolean} `true` if the location is inside of the range of the node.
|
||||
*/
|
||||
function isInRange(node, location) {
|
||||
return node && node.range[0] <= location && location <= node.range[1];
|
||||
return node && node.range[0] <= location && location <= node.range[1];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -54,15 +53,18 @@ function isInRange(node, location) {
|
||||
* @returns {boolean} `true` if the location is inside of a class static initializer.
|
||||
*/
|
||||
function isInClassStaticInitializerRange(node, location) {
|
||||
return node.body.some(
|
||||
classMember =>
|
||||
(classMember.type === "StaticBlock" &&
|
||||
isInRange(classMember, location)) ||
|
||||
(classMember.type === "PropertyDefinition" &&
|
||||
classMember.static &&
|
||||
classMember.value &&
|
||||
isInRange(classMember.value, location)),
|
||||
);
|
||||
return node.body.some(classMember => (
|
||||
(
|
||||
classMember.type === "StaticBlock" &&
|
||||
isInRange(classMember, location)
|
||||
) ||
|
||||
(
|
||||
classMember.type === "PropertyDefinition" &&
|
||||
classMember.static &&
|
||||
classMember.value &&
|
||||
isInRange(classMember.value, location)
|
||||
)
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -72,18 +74,19 @@ function isInClassStaticInitializerRange(node, location) {
|
||||
* @returns {boolean} `true` if the scope is a class static initializer scope.
|
||||
*/
|
||||
function isClassStaticInitializerScope(scope) {
|
||||
if (scope.type === "class-static-block") {
|
||||
return true;
|
||||
}
|
||||
if (scope.type === "class-static-block") {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (scope.type === "class-field-initializer") {
|
||||
// `scope.block` is PropertyDefinition#value node
|
||||
const propertyDefinition = scope.block.parent;
|
||||
if (scope.type === "class-field-initializer") {
|
||||
|
||||
return propertyDefinition.static;
|
||||
}
|
||||
// `scope.block` is PropertyDefinition#value node
|
||||
const propertyDefinition = scope.block.parent;
|
||||
|
||||
return false;
|
||||
return propertyDefinition.static;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -123,19 +126,19 @@ function isClassStaticInitializerScope(scope) {
|
||||
* @returns {boolean} `true` if the reference is from a separate execution context.
|
||||
*/
|
||||
function isFromSeparateExecutionContext(reference) {
|
||||
const variable = reference.resolved;
|
||||
let scope = reference.from;
|
||||
const variable = reference.resolved;
|
||||
let scope = reference.from;
|
||||
|
||||
// Scope#variableScope represents execution context
|
||||
while (variable.scope.variableScope !== scope.variableScope) {
|
||||
if (isClassStaticInitializerScope(scope.variableScope)) {
|
||||
scope = scope.variableScope.upper;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// Scope#variableScope represents execution context
|
||||
while (variable.scope.variableScope !== scope.variableScope) {
|
||||
if (isClassStaticInitializerScope(scope.variableScope)) {
|
||||
scope = scope.variableScope.upper;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -158,289 +161,188 @@ function isFromSeparateExecutionContext(reference) {
|
||||
* @returns {boolean} `true` if the reference is evaluated during the initialization.
|
||||
*/
|
||||
function isEvaluatedDuringInitialization(reference) {
|
||||
if (isFromSeparateExecutionContext(reference)) {
|
||||
/*
|
||||
* Even if the reference appears in the initializer, it isn't evaluated during the initialization.
|
||||
* For example, `const x = () => x;` is valid.
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
if (isFromSeparateExecutionContext(reference)) {
|
||||
|
||||
const location = reference.identifier.range[1];
|
||||
const definition = reference.resolved.defs[0];
|
||||
/*
|
||||
* Even if the reference appears in the initializer, it isn't evaluated during the initialization.
|
||||
* For example, `const x = () => x;` is valid.
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
|
||||
if (definition.type === "ClassName") {
|
||||
// `ClassDeclaration` or `ClassExpression`
|
||||
const classDefinition = definition.node;
|
||||
const location = reference.identifier.range[1];
|
||||
const definition = reference.resolved.defs[0];
|
||||
|
||||
return (
|
||||
isInRange(classDefinition, location) &&
|
||||
/*
|
||||
* Class binding is initialized before running static initializers.
|
||||
* For example, `class C { static foo = C; static { bar = C; } }` is valid.
|
||||
*/
|
||||
!isInClassStaticInitializerRange(classDefinition.body, location)
|
||||
);
|
||||
}
|
||||
if (definition.type === "ClassName") {
|
||||
|
||||
let node = definition.name.parent;
|
||||
// `ClassDeclaration` or `ClassExpression`
|
||||
const classDefinition = definition.node;
|
||||
|
||||
while (node) {
|
||||
if (node.type === "VariableDeclarator") {
|
||||
if (isInRange(node.init, location)) {
|
||||
return true;
|
||||
}
|
||||
if (
|
||||
FOR_IN_OF_TYPE.test(node.parent.parent.type) &&
|
||||
isInRange(node.parent.parent.right, location)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
} else if (node.type === "AssignmentPattern") {
|
||||
if (isInRange(node.right, location)) {
|
||||
return true;
|
||||
}
|
||||
} else if (SENTINEL_TYPE.test(node.type)) {
|
||||
break;
|
||||
}
|
||||
return (
|
||||
isInRange(classDefinition, location) &&
|
||||
|
||||
node = node.parent;
|
||||
}
|
||||
/*
|
||||
* Class binding is initialized before running static initializers.
|
||||
* For example, `class C { static foo = C; static { bar = C; } }` is valid.
|
||||
*/
|
||||
!isInClassStaticInitializerRange(classDefinition.body, location)
|
||||
);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
let node = definition.name.parent;
|
||||
|
||||
/**
|
||||
* check whether the reference contains a type query.
|
||||
* @param {ASTNode} node Identifier node to check.
|
||||
* @returns {boolean} true if reference contains type query.
|
||||
*/
|
||||
function referenceContainsTypeQuery(node) {
|
||||
switch (node.type) {
|
||||
case "TSTypeQuery":
|
||||
return true;
|
||||
while (node) {
|
||||
if (node.type === "VariableDeclarator") {
|
||||
if (isInRange(node.init, location)) {
|
||||
return true;
|
||||
}
|
||||
if (FOR_IN_OF_TYPE.test(node.parent.parent.type) &&
|
||||
isInRange(node.parent.parent.right, location)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
} else if (node.type === "AssignmentPattern") {
|
||||
if (isInRange(node.right, location)) {
|
||||
return true;
|
||||
}
|
||||
} else if (SENTINEL_TYPE.test(node.type)) {
|
||||
break;
|
||||
}
|
||||
|
||||
case "TSQualifiedName":
|
||||
case "Identifier":
|
||||
return referenceContainsTypeQuery(node.parent);
|
||||
node = node.parent;
|
||||
}
|
||||
|
||||
default:
|
||||
// if we find a different node, there's no chance that we're in a TSTypeQuery
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decorators are transpiled such that the decorator is placed after the class declaration
|
||||
* So it is considered safe
|
||||
* @param {Variable} variable The variable to check.
|
||||
* @param {Reference} reference The reference to check.
|
||||
* @returns {boolean} `true` if the reference is in a class decorator.
|
||||
*/
|
||||
function isClassRefInClassDecorator(variable, reference) {
|
||||
if (variable.defs[0].type !== "ClassName") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (
|
||||
!variable.defs[0].node.decorators ||
|
||||
variable.defs[0].node.decorators.length === 0
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (const deco of variable.defs[0].node.decorators) {
|
||||
if (
|
||||
reference.identifier.range[0] >= deco.range[0] &&
|
||||
reference.identifier.range[1] <= deco.range[1]
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
dialects: ["javascript", "typescript"],
|
||||
language: "javascript",
|
||||
type: "problem",
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow the use of variables before they are defined",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-use-before-define",
|
||||
},
|
||||
docs: {
|
||||
description: "Disallow the use of variables before they are defined",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-use-before-define"
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
oneOf: [
|
||||
{
|
||||
enum: ["nofunc"],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
functions: { type: "boolean" },
|
||||
classes: { type: "boolean" },
|
||||
variables: { type: "boolean" },
|
||||
allowNamedExports: { type: "boolean" },
|
||||
enums: { type: "boolean" },
|
||||
typedefs: { type: "boolean" },
|
||||
ignoreTypeReferences: { type: "boolean" },
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
schema: [
|
||||
{
|
||||
oneOf: [
|
||||
{
|
||||
enum: ["nofunc"]
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
functions: { type: "boolean" },
|
||||
classes: { type: "boolean" },
|
||||
variables: { type: "boolean" },
|
||||
allowNamedExports: { type: "boolean" }
|
||||
},
|
||||
additionalProperties: false
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
|
||||
defaultOptions: [
|
||||
{
|
||||
classes: true,
|
||||
functions: true,
|
||||
variables: true,
|
||||
allowNamedExports: false,
|
||||
enums: true,
|
||||
typedefs: true,
|
||||
ignoreTypeReferences: true,
|
||||
},
|
||||
],
|
||||
messages: {
|
||||
usedBeforeDefined: "'{{name}}' was used before it was defined."
|
||||
}
|
||||
},
|
||||
|
||||
messages: {
|
||||
usedBeforeDefined: "'{{name}}' was used before it was defined.",
|
||||
},
|
||||
},
|
||||
create(context) {
|
||||
const options = parseOptions(context.options[0]);
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
create(context) {
|
||||
const options = parseOptions(context.options[0]);
|
||||
const sourceCode = context.sourceCode;
|
||||
/**
|
||||
* Determines whether a given reference should be checked.
|
||||
*
|
||||
* Returns `false` if the reference is:
|
||||
* - initialization's (e.g., `let a = 1`).
|
||||
* - referring to an undefined variable (i.e., if it's an unresolved reference).
|
||||
* - referring to a variable that is defined, but not in the given source code
|
||||
* (e.g., global environment variable or `arguments` in functions).
|
||||
* - allowed by options.
|
||||
* @param {eslint-scope.Reference} reference The reference
|
||||
* @returns {boolean} `true` if the reference should be checked
|
||||
*/
|
||||
function shouldCheck(reference) {
|
||||
if (reference.init) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether a given reference should be checked.
|
||||
*
|
||||
* Returns `false` if the reference is:
|
||||
* - initialization's (e.g., `let a = 1`).
|
||||
* - referring to an undefined variable (i.e., if it's an unresolved reference).
|
||||
* - referring to a variable that is defined, but not in the given source code
|
||||
* (e.g., global environment variable or `arguments` in functions).
|
||||
* - allowed by options.
|
||||
* @param {eslint-scope.Reference} reference The reference
|
||||
* @returns {boolean} `true` if the reference should be checked
|
||||
*/
|
||||
function shouldCheck(reference) {
|
||||
if (reference.init) {
|
||||
return false;
|
||||
}
|
||||
const { identifier } = reference;
|
||||
|
||||
const { identifier } = reference;
|
||||
if (
|
||||
options.allowNamedExports &&
|
||||
identifier.parent.type === "ExportSpecifier" &&
|
||||
identifier.parent.local === identifier
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (
|
||||
options.allowNamedExports &&
|
||||
identifier.parent.type === "ExportSpecifier" &&
|
||||
identifier.parent.local === identifier
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
const variable = reference.resolved;
|
||||
|
||||
const variable = reference.resolved;
|
||||
if (!variable || variable.defs.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!variable || variable.defs.length === 0) {
|
||||
return false;
|
||||
}
|
||||
const definitionType = variable.defs[0].type;
|
||||
|
||||
const definitionType = variable.defs[0].type;
|
||||
if (!options.functions && definitionType === "FunctionName") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!options.functions && definitionType === "FunctionName") {
|
||||
return false;
|
||||
}
|
||||
if (
|
||||
(
|
||||
!options.variables && definitionType === "Variable" ||
|
||||
!options.classes && definitionType === "ClassName"
|
||||
) &&
|
||||
|
||||
if (
|
||||
((!options.variables && definitionType === "Variable") ||
|
||||
(!options.classes && definitionType === "ClassName")) &&
|
||||
// don't skip checking the reference if it's in the same execution context, because of TDZ
|
||||
isFromSeparateExecutionContext(reference)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
// don't skip checking the reference if it's in the same execution context, because of TDZ
|
||||
isFromSeparateExecutionContext(reference)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!options.enums && definitionType === "TSEnumName") {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!options.typedefs && definitionType === "Type") {
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Finds and validates all references in a given scope and its child scopes.
|
||||
* @param {eslint-scope.Scope} scope The scope object.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkReferencesInScope(scope) {
|
||||
scope.references.filter(shouldCheck).forEach(reference => {
|
||||
const variable = reference.resolved;
|
||||
const definitionIdentifier = variable.defs[0].name;
|
||||
|
||||
if (
|
||||
options.ignoreTypeReferences &&
|
||||
(referenceContainsTypeQuery(identifier) ||
|
||||
identifier.parent.type === "TSTypeReference")
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
if (
|
||||
reference.identifier.range[1] < definitionIdentifier.range[1] ||
|
||||
isEvaluatedDuringInitialization(reference)
|
||||
) {
|
||||
context.report({
|
||||
node: reference.identifier,
|
||||
messageId: "usedBeforeDefined",
|
||||
data: reference.identifier
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// skip nested namespace aliases as variable references
|
||||
if (identifier.parent.type === "TSQualifiedName") {
|
||||
let currentNode = identifier.parent;
|
||||
scope.childScopes.forEach(checkReferencesInScope);
|
||||
}
|
||||
|
||||
while (currentNode.type === "TSQualifiedName") {
|
||||
currentNode = currentNode.left;
|
||||
}
|
||||
|
||||
if (currentNode === identifier) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isClassRefInClassDecorator(variable, reference)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds and validates all references in a given scope and its child scopes.
|
||||
* @param {eslint-scope.Scope} scope The scope object.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkReferencesInScope(scope) {
|
||||
scope.references.filter(shouldCheck).forEach(reference => {
|
||||
const variable = reference.resolved;
|
||||
const definitionIdentifier = variable.defs[0].name;
|
||||
|
||||
if (
|
||||
reference.identifier.range[1] <
|
||||
definitionIdentifier.range[1] ||
|
||||
(isEvaluatedDuringInitialization(reference) &&
|
||||
reference.identifier.parent.type !== "TSTypeReference")
|
||||
) {
|
||||
context.report({
|
||||
node: reference.identifier,
|
||||
messageId: "usedBeforeDefined",
|
||||
data: reference.identifier,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
scope.childScopes.forEach(checkReferencesInScope);
|
||||
}
|
||||
|
||||
return {
|
||||
Program(node) {
|
||||
checkReferencesInScope(sourceCode.getScope(node));
|
||||
},
|
||||
};
|
||||
},
|
||||
return {
|
||||
Program(node) {
|
||||
checkReferencesInScope(sourceCode.getScope(node));
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user