chore: obey to the eslint rules

Author: freaktechnik

rules/from-map.js

@@ -41,46 +41,46 @@ module.exports = {
                             const OMIT_ITEM = 1,
                                 [
                                     mapCallback,
-                                    mapThisArg
+                                    mapThisArgument
                                 ] = node.arguments,
                                 [
                                     _, // eslint-disable-line no-unused-vars
                                     callback,
-                                    thisArg
+                                    thisArgument
                                 ] = parent.arguments,
                                 // Get the params names from the callback that has the most params (since the signature is identical).
-                                params = callback.params.length > mapCallback.params.length ? callback.params : mapCallback.params,
-                                paramString = params.map((p) => p.name).join(PARAM_SEPARATOR),
+                                parameters = callback.params.length > mapCallback.params.length ? callback.params : mapCallback.params,
+                                parameterString = parameters.map((p) => p.name).join(PARAM_SEPARATOR),
                                 getCallback = (cbk, targ, ps) => {
                                     const source = `(${sourceCode.getText(cbk)})`;
                                     if(targ && cbk.type !== ARROW_FUNCTION_EXPRESSION) {
                                         return `${source}.call(${targ.name}${PARAM_SEPARATOR}${ps})`;
                                     }
                                     return `${source}(${ps})`;
                                 },
-                                firstCallback = getCallback(callback, { name: 'this' }, paramString);
+                                firstCallback = getCallback(callback, { name: 'this' }, parameterString);
 
                             // Try to use an arrow function for the wrapping function, fall back to a function expression if a this is specified.
-                            let functionStart = `(${paramString}) => `,
+                            let functionStart = `(${parameterString}) => `,
                                 functionEnd = "",
-                                restParamString = '';
-                            if(thisArg && callback.type !== ARROW_FUNCTION_EXPRESSION) {
-                                functionStart = `function(${paramString}) { return `;
+                                restParameterString = '';
+                            if(thisArgument && callback.type !== ARROW_FUNCTION_EXPRESSION) {
+                                functionStart = `function(${parameterString}) { return `;
                                 functionEnd = "; }";
                             }
-                            if(params.length > OMIT_ITEM) {
-                                const restParams = params
+                            if(parameters.length > OMIT_ITEM) {
+                                const restParameters_ = parameters
                                     .slice(OMIT_ITEM)
                                     .map((p) => p.name);
-                                restParamString = PARAM_SEPARATOR + restParams.join(PARAM_SEPARATOR);
+                                restParameterString = PARAM_SEPARATOR + restParameters_.join(PARAM_SEPARATOR);
                             }
                             // The original map callback from Array.from gets nested as a parameter to the callback from map.
-                            const lastCallback = getCallback(mapCallback, mapThisArg, `${firstCallback}${restParamString}`),
-                                restParams = sourceCode.getText().slice(callback.end, parent.end);
+                            const lastCallback = getCallback(mapCallback, mapThisArgument, `${firstCallback}${restParameterString}`),
+                                restParameters = sourceCode.getText().slice(callback.end, parent.end);
                             return fixer.replaceTextRange([
                                 callback.start,
                                 node.end
-                            ], `${functionStart}${lastCallback}${functionEnd}${restParams}`);
+                            ], `${functionStart}${lastCallback}${functionEnd}${restParameters}`);
                         }
 
                         // Move the map arguments to from.

rules/no-unnecessary-this-arg.js

@@ -28,11 +28,11 @@ const {
     FUNC_POS = -2,
     //TODO should also check if the identifier is not an arrow function expression. Similar problem to array detection.
     checkFunction = (node, functionName, argumentPosition) => !isMethod(node, functionName) || node.arguments.length < argumentPosition || node.arguments[argumentPosition + FUNC_POS].type !== ARROW_FUNCTION_EXPRESSION,
-    checkArrayFunction = (functionName, paramPosition, node, context) => {
-        if(checkFunction(node, functionName, paramPosition) || !isOnObject(node, "Array")) {
+    checkArrayFunction = (functionName, parameterPosition, node, context) => {
+        if(checkFunction(node, functionName, parameterPosition) || !isOnObject(node, "Array")) {
             return;
         }
-        const argument = node.arguments[paramPosition - POS_TO_ARRAY];
+        const argument = node.arguments[parameterPosition - POS_TO_ARRAY];
         context.report({
             node: argument,
             loc: argument.loc,
@@ -42,9 +42,9 @@ const {
                 argument: argument.name
             },
             fix(fixer) {
-                const prevArgumentEnd = node.arguments[paramPosition + FUNC_POS].end;
+                const previousArgumentEnd = node.arguments[parameterPosition + FUNC_POS].end;
                 return fixer.removeRange([
-                    prevArgumentEnd,
+                    previousArgumentEnd,
                     argument.end
                 ]);
             }

rules/prefer-array-from.js

@@ -4,9 +4,9 @@
  */
 "use strict";
 
-const firstElement = (arr) => {
-    const [ el ] = arr;
-    return el;
+const firstElement = (array) => {
+    const [ element ] = array;
+    return element;
 };
 
 module.exports = {

rules/prefer-flat.js

@@ -37,13 +37,13 @@ module.exports = {
                 });
             },
             'CallExpression[callee.type="MemberExpression"][callee.property.name="reduce"][arguments.length=2][arguments.1.type=ArrayExpression][arguments.1.elements.length=0] > *:function[params.length=2][params.0.type=Identifier][params.1.type=Identifier] > CallExpression[callee.type="MemberExpression"][callee.property.name="concat"][arguments.length=1][arguments.0.type=Identifier]'(node) {
-                const reduceCallbackParams = node.parent.params;
+                const reduceCallbackParameters = node.parent.params;
 
                 // arr.reducer((a, b) => a.concat(b), [])
                 // "concat" function must be called on "a" and concat argument must be "b".
                 if(
-                    firstElement(node.arguments).name === secondElement(reduceCallbackParams).name &&
-                    node.callee.object.name === firstElement(reduceCallbackParams).name
+                    firstElement(node.arguments).name === secondElement(reduceCallbackParameters).name &&
+                    node.callee.object.name === firstElement(reduceCallbackParameters).name
                 ) {
                     context.report({
                         node: node.parent.parent,