Fixes code according to eslint rules

Author: nikolai-shabalin

index.js

@@ -1,3 +1,5 @@
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
 

rules/a-target-rel/index.js

@@ -1,20 +1,19 @@
-const { is_tag_node, attribute_has_value } = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const { is_tag_node, attribute_has_value } = require('@linthtml/dom-utils');
 const requiredAttributes = {
   // todo вынести в конфиг правила
-  rel: ["noreferrer", "noopener"]
+  rel: ['noreferrer', 'noopener']
 };
 
-const isEveryValuePresent = (node, attr, values) => {
-  return values.every(val => attribute_has_value(node, attr, new RegExp(val)))
-}
+const isEveryValuePresent = (node, attr, values) => values.every((val) => attribute_has_value(node, attr, new RegExp(val)));
 
-const isExternalLink = (node) => {
-  return is_tag_node(node) && node.name === "a" &&
-    attribute_has_value(node, 'target', '_blank')
-}
+const isExternalLink = (node) => is_tag_node(node) && node.name === 'a' &&
+    attribute_has_value(node, 'target', '_blank');
 
 module.exports = {
-  name: "htmlacademy/a-target-rel",
+  name: 'htmlacademy/a-target-rel',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
     if (isExternalLink(node)) {
       for (const [attr, values] of Object.entries(requiredAttributes)) {

rules/aria-label-misuse/index.js

@@ -1,14 +1,13 @@
-const {
-  is_tag_node,
-  has_non_empty_attribute,
-} = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const {is_tag_node, has_non_empty_attribute } = require('@linthtml/dom-utils');
 
 const whitelisted = [
-  "main", "nav", "table", "td", "th", "aside", "header", "footer", "section", "article", "summary",
+  'main', 'nav', 'table', 'td', 'th', 'aside', 'header', 'footer', 'section', 'article', 'summary',
 ];
 
 const interactive = [
-    "a", "audio", "button", "details", "iframe", "input", "label", "progress", "select", "textarea", "video",
+  'a', 'audio', 'button', 'details', 'iframe', 'input', 'label', 'progress', 'select', 'textarea', 'video',
 ];
 
 function isValidUsage(node) {
@@ -22,16 +21,17 @@ function isValidUsage(node) {
   }
 
   /* elements with tabindex (implicit interactive) are valid */
-  return has_non_empty_attribute(node, "tabindex");
+  return has_non_empty_attribute(node, 'tabindex');
 }
 
 module.exports = {
-  name: "htmlacademy/aria-label-misuse",
+  name: 'htmlacademy/aria-label-misuse',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
     if (is_tag_node(node) && has_non_empty_attribute(node, 'aria-label') && !isValidUsage(node)) {
       report({
         position: node.loc,
-        message: "\"aria-label\" cannot be used on this element",
+        message: '"aria-label" cannot be used on this element',
       });
     }
   },

rules/attr-delimiter/index.js

@@ -1,17 +1,20 @@
-const { is_tag_node } = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const { is_tag_node } = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/attr-delimiter",
+  name: 'htmlacademy/attr-delimiter',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
     if (is_tag_node(node)) {
       node.attributes.forEach((attribute) => {
         if (attribute.value?.chars.length > 0 && /\s/.test(attribute.equal.chars)) {
           report({
             position: attribute.loc,
-            message: "Attribute value must not be delimited by whitespace",
+            message: 'Attribute value must not be delimited by whitespace',
           });
         }
-      })
+      });
     }
   }
 };

rules/attr-req-value/index.js

@@ -1,16 +1,20 @@
-const { is_tag_node, has_non_empty_attribute, is_boolean_attribute} = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const { is_tag_node, has_non_empty_attribute, is_boolean_attribute} = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/attr-req-value",
+  name: 'htmlacademy/attr-req-value',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
     if (is_tag_node(node)) {
       const attributes = node.attributes.filter(({ name }) => /^¤+$/.test(name.chars) === false);
       attributes.forEach((attribute) => {
         const name = attribute.name.chars.toLowerCase();
 
+        // eslint-disable-next-line camelcase
         if (!has_non_empty_attribute(node, name) && !is_boolean_attribute(attribute) && !rule_config.ignore?.includes(name)) {
           report({
-            code: "E006",
+            code: 'E006',
             position: attribute.loc,
             meta: {
               data: {
@@ -22,4 +26,4 @@ module.exports = {
       });
     }
   }
-}
+};

rules/attribute-allowed-values/index.js

@@ -1,18 +1,23 @@
-const { is_tag_node, has_non_empty_attribute, is_boolean_attribute } = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const { is_tag_node, has_non_empty_attribute, is_boolean_attribute } = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/attribute-allowed-values",
+  name: 'htmlacademy/attribute-allowed-values',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
+    // eslint-disable-next-line camelcase
     if (is_tag_node(node) && node.name.chars in rule_config) {
+      // eslint-disable-next-line camelcase
       const { attributes: restrictedAttributes } = rule_config[node.name.chars];
       const attributes = node.attributes.filter(
-          (attribute) => /^¤+$/.test(attribute.name.chars) === false
+        (attribute) => /^¤+$/.test(attribute.name.chars) === false
           && has_non_empty_attribute(node, attribute.name.chars) && !is_boolean_attribute(attribute)
           && attribute.name.chars in restrictedAttributes
       );
       attributes.forEach((attribute) => {
         const { enum: allowedValues } = restrictedAttributes[attribute.name.chars];
-        const value = attribute.value.chars.toLowerCase()
+        const value = attribute.value.chars.toLowerCase();
         if (!allowedValues.includes(value)) {
           const name = attribute.name.chars;
           report({
@@ -23,4 +28,4 @@ module.exports = {
       });
     }
   }
-}
+};

rules/ban-url-spaces/index.js

@@ -1,24 +1,28 @@
-const { is_tag_node, has_non_empty_attribute } = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const { is_tag_node } = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/ban-url-spaces",
+  name: 'htmlacademy/ban-url-spaces',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
     if (is_tag_node(node)) {
-      const checkList = rule_config.attributes || ['href', 'src']
+      // eslint-disable-next-line camelcase
+      const checkList = rule_config.attributes || ['href', 'src'];
       const attributes = node.attributes.filter(
-          ({ name }) => checkList.includes(name.chars)
-      )
+        ({ name }) => checkList.includes(name.chars)
+      );
       if (!attributes.length) {
-        return
+        return;
       }
       attributes.forEach((item) => {
         if (/\s/.test(item.value?.chars)) {
           report({
             position: item.loc,
-            message: `Spaces in URL not allowed.`
+            message: 'Spaces in URL not allowed.'
           });
         }
-      })
+      });
     }
   },
 };

rules/charset-position/index.js

@@ -1,21 +1,25 @@
-const dom_utils = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const dom_utils = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/charset-position",
+  name: 'htmlacademy/charset-position',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
-    if (dom_utils.is_tag_node(node) && node.name === "head") {
-      const childrenWithoutText = node.children.filter(children => children.type !== 'text');
+    // eslint-disable-next-line camelcase
+    if (dom_utils.is_tag_node(node) && node.name === 'head') {
+      const childrenWithoutText = node.children.filter((children) => children.type !== 'text');
       const firstElement = childrenWithoutText[0];
       const hasMeta = firstElement.name === 'meta';
-      const hasUtf = firstElement.attributes.some(attribute => attribute.value.chars.toLowerCase() === 'utf-8');
-      const hasCharset = firstElement.attributes.some(attribute => attribute.name.chars === "charset");
+      const hasUtf = firstElement.attributes.some((attribute) => attribute.value.chars.toLowerCase() === 'utf-8');
+      const hasCharset = firstElement.attributes.some((attribute) => attribute.name.chars === 'charset');
 
       if (!hasMeta && !hasUtf && !hasCharset) {
         report({
           position: node.loc,
-          message: `<meta charset=""> is not the first child element in <head>`,
+          message: '<meta charset=""> is not the first child element in <head>',
         });
       }
     }
   }
-}
+};

rules/class-first/index.js

@@ -1,16 +1,21 @@
-const dom_utils = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const dom_utils = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/class-first",
+  name: 'htmlacademy/class-first',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
+    // eslint-disable-next-line camelcase
     if (dom_utils.is_tag_node(node) === false) {
       return;
     }
+    // eslint-disable-next-line camelcase
     const attribute = dom_utils.get_attribute(node, 'class');
     if (attribute && attribute !== node.attributes[0]) {
       report({
         position: attribute.loc,
-        message: `The class attribute should be the first.`,
+        message: 'The class attribute should be the first.',
       });
     }
   }

rules/form-action-attribute/index.js

@@ -1,22 +1,26 @@
-const dom_utils = require("@linthtml/dom-utils");
+'use strict';
+// eslint-disable-next-line camelcase
+const dom_utils = require('@linthtml/dom-utils');
 
 module.exports = {
-  name: "htmlacademy/form-action-attribute",
+  name: 'htmlacademy/form-action-attribute',
+  // eslint-disable-next-line camelcase
   lint(node, rule_config, { report }) {
-    if (dom_utils.is_tag_node(node) && node.name === "form") {
+    // eslint-disable-next-line camelcase
+    if (dom_utils.is_tag_node(node) && node.name === 'form') {
       const actionAttribute = node.attributes.find(
-        (attr) => attr.name.chars === "action"
+        (attr) => attr.name.chars === 'action'
       );
 
       if (!actionAttribute) {
         report({
           position: node.loc,
-          message: `The <form> element is missing the "action" attribute.`,
+          message: 'The <form> element is missing the "action" attribute.',
         });
       } else if (actionAttribute.value === null) {
         report({
           position: actionAttribute.loc,
-          message: `The value of the "action" attribute for the <form> element is empty.`,
+          message: 'The value of the "action" attribute for the <form> element is empty.',
         });
       }
     }