Server IP : 150.95.80.236 / Your IP : 3.14.131.180 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/eslint/lib/rules/ |
Upload File : |
/** * @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('../shared/types').Rule} */ module.exports = { meta: { type: "suggestion", docs: { description: "Require destructuring from arrays and/or objects", recommended: false, 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 }; } };