Current File : /home/vacivi36/SiteVacivitta/vacivitta/node_modules/eslint/lib/rules/prefer-destructuring.js
/**
* @fileoverview Prefer destructuring from arrays and objects
* @author Alex LaFroscia
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({
type: "AssignmentExpression",
});
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
type: "suggestion",
docs: {
description: "Require destructuring from arrays and/or objects",
recommended: false,
frozen: true,
url: "https://eslint.org/docs/latest/rules/prefer-destructuring",
},
fixable: "code",
schema: [
{
/*
* old support {array: Boolean, object: Boolean}
* new support {VariableDeclarator: {}, AssignmentExpression: {}}
*/
oneOf: [
{
type: "object",
properties: {
VariableDeclarator: {
type: "object",
properties: {
array: {
type: "boolean",
},
object: {
type: "boolean",
},
},
additionalProperties: false,
},
AssignmentExpression: {
type: "object",
properties: {
array: {
type: "boolean",
},
object: {
type: "boolean",
},
},
additionalProperties: false,
},
},
additionalProperties: false,
},
{
type: "object",
properties: {
array: {
type: "boolean",
},
object: {
type: "boolean",
},
},
additionalProperties: false,
},
],
},
{
type: "object",
properties: {
enforceForRenamedProperties: {
type: "boolean",
},
},
additionalProperties: false,
},
],
messages: {
preferDestructuring: "Use {{type}} destructuring.",
},
},
create(context) {
const enabledTypes = context.options[0];
const enforceForRenamedProperties =
context.options[1] &&
context.options[1].enforceForRenamedProperties;
let normalizedOptions = {
VariableDeclarator: { array: true, object: true },
AssignmentExpression: { array: true, object: true },
};
if (enabledTypes) {
normalizedOptions =
typeof enabledTypes.array !== "undefined" ||
typeof enabledTypes.object !== "undefined"
? {
VariableDeclarator: enabledTypes,
AssignmentExpression: enabledTypes,
}
: enabledTypes;
}
//--------------------------------------------------------------------------
// Helpers
//--------------------------------------------------------------------------
/**
* Checks if destructuring type should be checked.
* @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
* @param {string} destructuringType "array" or "object"
* @returns {boolean} `true` if the destructuring type should be checked for the given node
*/
function shouldCheck(nodeType, destructuringType) {
return (
normalizedOptions &&
normalizedOptions[nodeType] &&
normalizedOptions[nodeType][destructuringType]
);
}
/**
* Determines if the given node is accessing an array index
*
* This is used to differentiate array index access from object property
* access.
* @param {ASTNode} node the node to evaluate
* @returns {boolean} whether or not the node is an integer
*/
function isArrayIndexAccess(node) {
return Number.isInteger(node.property.value);
}
/**
* Report that the given node should use destructuring
* @param {ASTNode} reportNode the node to report
* @param {string} type the type of destructuring that should have been done
* @param {Function|null} fix the fix function or null to pass to context.report
* @returns {void}
*/
function report(reportNode, type, fix) {
context.report({
node: reportNode,
messageId: "preferDestructuring",
data: { type },
fix,
});
}
/**
* Determines if a node should be fixed into object destructuring
*
* The fixer only fixes the simplest case of object destructuring,
* like: `let x = a.x`;
*
* Assignment expression is not fixed.
* Array destructuring is not fixed.
* Renamed property is not fixed.
* @param {ASTNode} node the node to evaluate
* @returns {boolean} whether or not the node should be fixed
*/
function shouldFix(node) {
return (
node.type === "VariableDeclarator" &&
node.id.type === "Identifier" &&
node.init.type === "MemberExpression" &&
!node.init.computed &&
node.init.property.type === "Identifier" &&
node.id.name === node.init.property.name
);
}
/**
* Fix a node into object destructuring.
* This function only handles the simplest case of object destructuring,
* see {@link shouldFix}.
* @param {SourceCodeFixer} fixer the fixer object
* @param {ASTNode} node the node to be fixed.
* @returns {Object} a fix for the node
*/
function fixIntoObjectDestructuring(fixer, node) {
const rightNode = node.init;
const sourceCode = context.sourceCode;
// Don't fix if that would remove any comments. Only comments inside `rightNode.object` can be preserved.
if (
sourceCode.getCommentsInside(node).length >
sourceCode.getCommentsInside(rightNode.object).length
) {
return null;
}
let objectText = sourceCode.getText(rightNode.object);
if (
astUtils.getPrecedence(rightNode.object) <
PRECEDENCE_OF_ASSIGNMENT_EXPR
) {
objectText = `(${objectText})`;
}
return fixer.replaceText(
node,
`{${rightNode.property.name}} = ${objectText}`,
);
}
/**
* Check that the `prefer-destructuring` rules are followed based on the
* given left- and right-hand side of the assignment.
*
* Pulled out into a separate method so that VariableDeclarators and
* AssignmentExpressions can share the same verification logic.
* @param {ASTNode} leftNode the left-hand side of the assignment
* @param {ASTNode} rightNode the right-hand side of the assignment
* @param {ASTNode} reportNode the node to report the error on
* @returns {void}
*/
function performCheck(leftNode, rightNode, reportNode) {
if (
rightNode.type !== "MemberExpression" ||
rightNode.object.type === "Super" ||
rightNode.property.type === "PrivateIdentifier"
) {
return;
}
if (isArrayIndexAccess(rightNode)) {
if (shouldCheck(reportNode.type, "array")) {
report(reportNode, "array", null);
}
return;
}
const fix = shouldFix(reportNode)
? fixer => fixIntoObjectDestructuring(fixer, reportNode)
: null;
if (
shouldCheck(reportNode.type, "object") &&
enforceForRenamedProperties
) {
report(reportNode, "object", fix);
return;
}
if (shouldCheck(reportNode.type, "object")) {
const property = rightNode.property;
if (
(property.type === "Literal" &&
leftNode.name === property.value) ||
(property.type === "Identifier" &&
leftNode.name === property.name &&
!rightNode.computed)
) {
report(reportNode, "object", fix);
}
}
}
/**
* Check if a given variable declarator is coming from an property access
* that should be using destructuring instead
* @param {ASTNode} node the variable declarator to check
* @returns {void}
*/
function checkVariableDeclarator(node) {
// Skip if variable is declared without assignment
if (!node.init) {
return;
}
// We only care about member expressions past this point
if (node.init.type !== "MemberExpression") {
return;
}
performCheck(node.id, node.init, node);
}
/**
* Run the `prefer-destructuring` check on an AssignmentExpression
* @param {ASTNode} node the AssignmentExpression node
* @returns {void}
*/
function checkAssignmentExpression(node) {
if (node.operator === "=") {
performCheck(node.left, node.right, node);
}
}
//--------------------------------------------------------------------------
// Public
//--------------------------------------------------------------------------
return {
VariableDeclarator: checkVariableDeclarator,
AssignmentExpression: checkAssignmentExpression,
};
},
};
Mini Shell