tools: update ESLint custom rules to not use the deprecated format

Refs: https://eslint.org/docs/latest/extend/custom-rules-deprecated PR-URL: #46460 Reviewed-By: Michaël Zasso <[email protected]> Reviewed-By: Luigi Pinca <[email protected]> Reviewed-By: James M Snell <[email protected]>

Author: aduh95

tools/eslint-rules/lowercase-name-for-primitive.js

@@ -14,46 +14,45 @@ const astSelector = 'NewExpression[callee.property.name="TypeError"]' +
 
 constprimitives=['number','string','boolean','null','undefined'];
 
-module.exports=function(context){
-functioncheckNamesArgument(node){
-constnames=node.arguments[2];
-
-switch(names.type){
-case'Literal':
-checkName(names);
-break;
-case'ArrayExpression':
-names.elements.forEach((name)=>{
-checkName(name);
-});
-break;
-}
-}
-
-functioncheckName(node){
-constname=node.value;
-constlowercaseName=name.toLowerCase();
-if(name!==lowercaseName&&primitives.includes(lowercaseName)){
-constmsg=`primitive should use lowercase: ${name}`;
-context.report({
- node,
-message: msg,
-fix: (fixer)=>{
-returnfixer.replaceText(
-node,
-`'${lowercaseName}'`,
-);
-},
-});
+module.exports={
+meta: {fixable: 'code'},
+create(context){
+functioncheckNamesArgument(node){
+constnames=node.arguments[2];
+
+switch(names.type){
+case'Literal':
+checkName(names);
+break;
+case'ArrayExpression':
+names.elements.forEach((name)=>{
+checkName(name);
+});
+break;
+}
 }
 
-}
+functioncheckName(node){
+constname=node.value;
+constlowercaseName=name.toLowerCase();
+if(name!==lowercaseName&&primitives.includes(lowercaseName)){
+constmsg=`primitive should use lowercase: ${name}`;
+context.report({
+ node,
+message: msg,
+fix: (fixer)=>{
+returnfixer.replaceText(
+node,
+`'${lowercaseName}'`,
+);
+},
+});
+}
 
-return{
-[astSelector]: (node)=>checkNamesArgument(node),
-};
-};
+}
 
-module.exports.meta={
-fixable: 'code',
+return{
+[astSelector]: (node)=>checkNamesArgument(node),
+};
+},
 };

tools/eslint-rules/prefer-assert-methods.js

@@ -19,30 +19,29 @@ const preferredAssertMethod ={
 '!=': 'notEqual',
 };
 
-module.exports=function(context){
-return{
-[astSelector]: function(node){
-constarg=node.expression.arguments[0];
-constassertMethod=preferredAssertMethod[arg.operator];
-if(assertMethod){
-context.report({
- node,
-message: parseError(assertMethod,arg.operator),
-fix: (fixer)=>{
-constsourceCode=context.getSourceCode();
-constleft=sourceCode.getText(arg.left);
-constright=sourceCode.getText(arg.right);
-returnfixer.replaceText(
-node,
-`assert.${assertMethod}(${left}, ${right});`,
-);
-},
-});
-}
-},
-};
-};
-
-module.exports.meta={
-fixable: 'code',
+module.exports={
+meta: {fixable: 'code'},
+create(context){
+return{
+[astSelector]: function(node){
+constarg=node.expression.arguments[0];
+constassertMethod=preferredAssertMethod[arg.operator];
+if(assertMethod){
+context.report({
+ node,
+message: parseError(assertMethod,arg.operator),
+fix: (fixer)=>{
+constsourceCode=context.getSourceCode();
+constleft=sourceCode.getText(arg.left);
+constright=sourceCode.getText(arg.right);
+returnfixer.replaceText(
+node,
+`assert.${assertMethod}(${left}, ${right});`,
+);
+},
+});
+}
+},
+};
+},
 };

tools/eslint-rules/prefer-common-mustnotcall.js

@@ -15,16 +15,18 @@ const mustCallSelector = 'CallExpression[callee.object.name="common"]' +
 constarg0Selector=`${mustCallSelector}[arguments.0.value=0]`;
 constarg1Selector=`${mustCallSelector}[arguments.1.value=0]`;
 
-module.exports=function(context){
-functionreport(node){
-context.report(node,msg);
-}
+module.exports={
+create(context){
+functionreport(node){
+context.report(node,msg);
+}
 
-return{
+return{
 // Catch common.mustCall(0)
-[arg0Selector]: report,
+[arg0Selector]: report,
 
-// Catch common.mustCall(fn, 0)
-[arg1Selector]: report,
-};
+// Catch common.mustCall(fn, 0)
+[arg1Selector]: report,
+};
+},
 };

tools/eslint-rules/require-common-first.js

@@ -10,72 +10,74 @@ const{isRequireCall, isString } = require('./rules-utils.js');
 // Rule Definition
 //------------------------------------------------------------------------------
 
-module.exports=function(context){
-constrequiredModule='common';
-constisESM=context.parserOptions.sourceType==='module';
-constfoundModules=[];
+module.exports={
+create(context){
+constrequiredModule='common';
+constisESM=context.parserOptions.sourceType==='module';
+constfoundModules=[];
 
-/**
- * Function to check if the path is a module and return its name.
- * @param{string} str The path to check
- * @returns{string} module name
- */
-functiongetModuleName(str){
-if(str==='../common/index.mjs'){
-return'common';
-}
+/**
+* Function to check if the path is a module and return its name.
+* @param{string} str The path to check
+* @returns{string} module name
+*/
+functiongetModuleName(str){
+if(str==='../common/index.mjs'){
+return'common';
+}
 
-returnpath.basename(str);
-}
+returnpath.basename(str);
+}
 
-/**
- * Function to check if a node has an argument that is a module and
- * return its name.
- * @param{ASTNode} node The node to check
- * @returns{undefined | string} module name or undefined
- */
-functiongetModuleNameFromCall(node){
+/**
+* Function to check if a node has an argument that is a module and
+* return its name.
+* @param{ASTNode} node The node to check
+* @returns{undefined | string} module name or undefined
+*/
+functiongetModuleNameFromCall(node){
 // Node has arguments and first argument is string
-if(node.arguments.length&&isString(node.arguments[0])){
-returngetModuleName(node.arguments[0].value.trim());
-}
+if(node.arguments.length&&isString(node.arguments[0])){
+returngetModuleName(node.arguments[0].value.trim());
+}
 
-returnundefined;
-}
+returnundefined;
+}
 
-construles={
-'Program:exit'(node){
+construles={
+'Program:exit'(node){
 // The common module should be loaded in the first place.
-constnotLoadedFirst=foundModules.indexOf(requiredModule)!==0;
-if(notLoadedFirst){
-context.report(
-node,
-'Mandatory module "{{moduleName}}" must be loaded '+
+constnotLoadedFirst=foundModules.indexOf(requiredModule)!==0;
+if(notLoadedFirst){
+context.report(
+node,
+'Mandatory module "{{moduleName}}" must be loaded '+
 'before any other modules.',
-{moduleName: requiredModule},
-);
-}
-},
-};
-
-if(isESM){
-rules.ImportDeclaration=(node)=>{
-constmoduleName=getModuleName(node.source.value);
-if(moduleName){
-foundModules.push(moduleName);
-}
+{moduleName: requiredModule},
+);
+}
+},
 };
-}else{
-rules.CallExpression=(node)=>{
-if(isRequireCall(node)){
-constmoduleName=getModuleNameFromCall(node);
 
+if(isESM){
+rules.ImportDeclaration=(node)=>{
+constmoduleName=getModuleName(node.source.value);
 if(moduleName){
 foundModules.push(moduleName);
 }
-}
-};
-}
+};
+}else{
+rules.CallExpression=(node)=>{
+if(isRequireCall(node)){
+constmoduleName=getModuleNameFromCall(node);
+
+if(moduleName){
+foundModules.push(moduleName);
+}
+}
+};
+}
 
-returnrules;
+returnrules;
+},
 };