@html-eslint/eslint-plugin 0.35.0-alpha.0 → 0.35.1

package/lib/rules/attrs-newline.js

@@ -1,11 +1,16 @@
 /**
- * @typedef { import("eslint").Rule.RuleFixer } RuleFixer
- * @typedef { import("../types").RuleModule } RuleModule
+ * @typedef { import("../types").RuleFixer } RuleFixer
  *
- * @typedef {Object } MessageId
+ * @typedef {Object} MessageId
  * @property {"closeStyleWrong"} CLOSE_STYLE_WRONG
  * @property {"newlineMissing"} NEWLINE_MISSING
  * @property {"newlineUnexpected"} NEWLINE_UNEXPECTED
+ *
+ * @typedef {Object} Option
+ * @property {"sameline" | "newline"} [option.closeStyle]
+ * @property {number} [options.ifAttrsMoreThan]
+ *
+ * @typedef { import("../types").RuleModule<[Option]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");
@@ -58,9 +63,8 @@ module.exports = {
 
   create(context) {
     const options = context.options[0] || {};
-    const attrMin = isNaN(options.ifAttrsMoreThan)
-      ? 2
-      : options.ifAttrsMoreThan;
+    const attrMin =
+      typeof options.ifAttrsMoreThan !== "number" ? 2 : options.ifAttrsMoreThan;
     const closeStyle = options.closeStyle || "newline";
 
     return createVisitors(context, {
@@ -147,7 +151,7 @@ module.exports = {
             return context.report({
               node,
               data: {
-                attrMin,
+                attrMin: `${attrMin}`,
               },
               fix,
               messageId: MESSAGE_ID.NEWLINE_UNEXPECTED,

package/lib/rules/element-newline.js

@@ -1,27 +1,36 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").Comment } Comment
- * @typedef { import("../types").Doctype } Doctype
- * @typedef { import("../types").ScriptTag } ScriptTag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").Text } Text
- * @typedef { Tag | Doctype | ScriptTag | StyleTag | Text } NewlineNode
- * @typedef {{
- *   childFirst: NewlineNode | null;
- *   childLast: NewlineNode | null;
- *   shouldBeNewline: boolean;
- * }} NodeMeta
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").Comment } Comment
+ * @typedef { import("@html-eslint/types").Doctype } Doctype
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").Text } Text
+ * @typedef { import("@html-eslint/types").AnyNode } AnyNode
+ * @typedef { import("@html-eslint/types").OpenTagEnd } OpenTagEnd
+ * @typedef { import("@html-eslint/types").CloseTag } CloseTag
+ * @typedef { import("../types").Line } Line
+ * @typedef { AnyNode | Line } AnyNodeOrLine
+ *
+ * @typedef {Object} Option
+ * @property {string[]} [Option.skip]
+ * @property {string[]} [Option.inline]
+ *
+ * @typedef { import("../types").RuleModule<[Option]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");
-const { isTag, isComment, isText } = require("./utils/node");
+const {
+  isTag,
+  isComment,
+  isText,
+  splitToLineNodes,
+  isLine,
+  isScript,
+  isStyle,
+} = require("./utils/node");
 const { createVisitors } = require("./utils/visitors");
 const MESSAGE_IDS = {
   EXPECT_NEW_LINE_AFTER: "expectAfter",
-  EXPECT_NEW_LINE_AFTER_OPEN: "expectAfterOpen",
-  EXPECT_NEW_LINE_BEFORE: "expectBefore",
-  EXPECT_NEW_LINE_BEFORE_CLOSE: "expectBeforeClose",
 };
 
 /**
@@ -100,167 +109,169 @@ module.exports = {
     ],
     messages: {
       [MESSAGE_IDS.EXPECT_NEW_LINE_AFTER]:
-        "There should be a linebreak after {{tag}} element.",
-      [MESSAGE_IDS.EXPECT_NEW_LINE_AFTER_OPEN]:
-        "There should be a linebreak after {{tag}} open.",
-      [MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE]:
-        "There should be a linebreak before {{tag}} element.",
-      [MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE_CLOSE]:
-        "There should be a linebreak before {{tag}} close.",
+        "There should be a linebreak after {{name}}.",
     },
   },
 
   create(context) {
     const option = context.options[0] || {};
-    const skipTags = option.skip || [];
+    /**
+     * @type {string[]}
+     */
+    const skipTags = option.skip || ["pre", "code"];
     const inlineTags = optionsOrPresets(option.inline || []);
 
     /**
-     * @param {Array<NewlineNode>} siblings
-     * @returns {NodeMeta} meta
+     * @param {AnyNodeOrLine[]} children
+     * @returns {Exclude<AnyNodeOrLine, Text>[]}
      */
-    function checkSiblings(siblings) {
+    function getChildrenToCheck(children) {
       /**
-       * @type {NodeMeta}
+       * @type {Exclude<AnyNodeOrLine, Text>[]}
        */
-      const meta = {
-        childFirst: null,
-        childLast: null,
-        shouldBeNewline: false,
-      };
-
-      const nodesWithContent = [];
-      for (
-        let length = siblings.length, index = 0;
-        index < length;
-        index += 1
-      ) {
-        const node = siblings[index];
+      const childrenToCheck = [];
 
-        if (isEmptyText(node) === false) {
-          nodesWithContent.push(node);
+      for (const child of children) {
+        if (isText(child)) {
+          const lines = splitToLineNodes(child);
+          childrenToCheck.push(...lines);
+          continue;
         }
+        childrenToCheck.push(child);
       }
+      return childrenToCheck.filter((child) => !isEmptyText(child));
+    }
 
-      for (
-        let length = nodesWithContent.length, index = 0;
-        index < length;
-        index += 1
-      ) {
-        const node = nodesWithContent[index];
-        const nodeNext = nodesWithContent[index + 1];
+    /**
+     * @param {AnyNodeOrLine} before
+     * @param {AnyNodeOrLine} after
+     * @returns {boolean}
+     */
+    function isOnTheSameLine(before, after) {
+      return before.loc.end.line === after.loc.start.line;
+    }
 
-        if (meta.childFirst === null) {
-          meta.childFirst = node;
-        }
+    /**
+     * @param {AnyNode} node
+     * @returns {boolean}
+     */
+    function shouldSkipChildren(node) {
+      if (isTag(node) && skipTags.includes(node.name.toLowerCase())) {
+        return true;
+      }
+      return false;
+    }
 
-        meta.childLast = node;
+    /**
+     * @param {AnyNodeOrLine} node
+     * @returns {boolean}
+     */
+    function isInline(node) {
+      return (
+        isLine(node) ||
+        (isTag(node) && inlineTags.includes(node.name.toLowerCase()))
+      );
+    }
+
+    /**
+     * @param {AnyNode[]} children
+     * @param {AnyNode} parent
+     * @param {[OpenTagEnd, CloseTag]} [wrapper]
+     */
+    function checkChildren(children, parent, wrapper) {
+      if (shouldSkipChildren(parent)) {
+        return;
+      }
 
-        const nodeShouldBeNewline = shouldBeNewline(node);
+      const childrenToCheck = getChildrenToCheck(children);
+      const firstChild = childrenToCheck[0];
+      if (
+        wrapper &&
+        firstChild &&
+        childrenToCheck.some((child) => !isInline(child))
+      ) {
+        const open = wrapper[0];
+        if (isOnTheSameLine(open, firstChild)) {
+          context.report({
+            node: open,
+            messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
+            data: { name: getName(parent) },
+            fix(fixer) {
+              return fixer.insertTextAfter(open, `\n`);
+            },
+          });
+        }
+      }
 
-        if (isTag(node) && skipTags.includes(node.name) === false) {
-          const nodeMeta = checkSiblings(node.children);
-          const nodeChildShouldBeNewline = nodeMeta.shouldBeNewline;
+      childrenToCheck.forEach((current, index) => {
+        const next = childrenToCheck[index + 1];
 
-          if (nodeShouldBeNewline || nodeChildShouldBeNewline) {
-            meta.shouldBeNewline = true;
-          }
+        if (
+          !next ||
+          !isOnTheSameLine(current, next) ||
+          (isInline(current) && isInline(next))
+        ) {
+          return;
+        }
 
-          if (
-            nodeShouldBeNewline &&
-            nodeChildShouldBeNewline &&
-            nodeMeta.childFirst &&
-            nodeMeta.childLast
-          ) {
-            if (
-              node.openEnd.loc.end.line === nodeMeta.childFirst.loc.start.line
-            ) {
-              if (isNotNewlineStart(nodeMeta.childFirst)) {
-                context.report({
-                  node: node,
-                  messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER_OPEN,
-                  data: { tag: label(node) },
-                  fix(fixer) {
-                    return fixer.insertTextAfter(node.openEnd, `\n`);
-                  },
-                });
-              }
-            }
+        context.report({
+          node: current,
+          messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
+          data: { name: getName(current, { isClose: true }) },
+          fix(fixer) {
+            return fixer.insertTextAfter(current, `\n`);
+          },
+        });
+      });
 
-            if (
-              node.close &&
-              nodeMeta.childLast.loc.end.line === node.close.loc.start.line
-            ) {
-              if (isNotNewlineEnd(nodeMeta.childLast)) {
-                context.report({
-                  node: node,
-                  messageId: MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE_CLOSE,
-                  data: { tag: label(node, { isClose: true }) },
-                  fix(fixer) {
-                    return fixer.insertTextBefore(node.close, `\n`);
-                  },
-                });
-              }
-            }
-          }
+      childrenToCheck.forEach((child) => {
+        if (isTag(child)) {
+          /**
+           * @type {[OpenTagEnd, CloseTag] | undefined}
+           */
+          const wrapper = child.close
+            ? [child.openEnd, child.close]
+            : undefined;
+          checkChildren(child.children, child, wrapper);
         }
+      });
 
-        if (nodeNext && node.loc.end.line === nodeNext.loc.start.line) {
-          if (nodeShouldBeNewline) {
-            if (isNotNewlineStart(nodeNext)) {
-              context.report({
-                node: nodeNext,
-                messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
-                data: { tag: label(node) },
-                fix(fixer) {
-                  return fixer.insertTextAfter(node, `\n`);
-                },
-              });
-            }
-          } else if (shouldBeNewline(nodeNext)) {
-            if (isNotNewlineEnd(node)) {
-              context.report({
-                node: nodeNext,
-                messageId: MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE,
-                data: { tag: label(nodeNext) },
-                fix(fixer) {
-                  return fixer.insertTextBefore(nodeNext, `\n`);
-                },
-              });
-            }
-          }
+      const lastChild = childrenToCheck[childrenToCheck.length - 1];
+      if (
+        wrapper &&
+        lastChild &&
+        childrenToCheck.some((child) => !isInline(child))
+      ) {
+        const close = wrapper[1];
+        if (isOnTheSameLine(close, lastChild)) {
+          context.report({
+            node: lastChild,
+            messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
+            data: { name: getName(lastChild, { isClose: true }) },
+            fix(fixer) {
+              return fixer.insertTextAfter(lastChild, `\n`);
+            },
+          });
         }
       }
-
-      return meta;
     }
 
     /**
-     * @param {NewlineNode} node
+     * @param {AnyNodeOrLine} node
+     * @returns {boolean}
      */
     function isEmptyText(node) {
-      return node.type === `Text` && node.value.trim().length === 0;
-    }
-
-    /**
-     * @param {NewlineNode} node
-     */
-    function isNotNewlineEnd(node) {
-      return node.type !== `Text` || /(\n|\r\n)\s*$/.test(node.value) === false;
-    }
-
-    /**
-     * @param {NewlineNode} node
-     */
-    function isNotNewlineStart(node) {
-      return node.type !== `Text` || /^(\n|\r\n)/.test(node.value) === false;
+      return (
+        (isText(node) && node.value.trim().length === 0) ||
+        (isLine(node) && node.value.trim().length === 0)
+      );
     }
 
     /**
-     * @param {NewlineNode} node
+     * @param {AnyNodeOrLine} node
      * @param {{ isClose?: boolean }} options
      */
-    function label(node, options = {}) {
+    function getName(node, options = {}) {
       const isClose = options.isClose || false;
       if (isTag(node)) {
         if (isClose) {
@@ -268,6 +279,24 @@ module.exports = {
         }
         return `<${node.name}>`;
       }
+      if (isLine(node)) {
+        return "text";
+      }
+      if (isComment(node)) {
+        return "comment";
+      }
+      if (isScript(node)) {
+        if (isClose) {
+          return `</script>`;
+        }
+        return "<script>";
+      }
+      if (isStyle(node)) {
+        if (isClose) {
+          return `</style>`;
+        }
+        return "<style>";
+      }
       return `<${node.type}>`;
     }
 
@@ -287,26 +316,9 @@ module.exports = {
       return result;
     }
 
-    /**
-     * @param {NewlineNode} node
-     */
-    function shouldBeNewline(node) {
-      if (isComment(node)) {
-        return /[\n\r]+/.test(node.value.value.trim());
-      }
-      if (isTag(node)) {
-        return inlineTags.includes(node.name.toLowerCase()) === false;
-      }
-      if (isText(node)) {
-        return /[\n\r]+/.test(node.value.trim());
-      }
-      return true;
-    }
-
     return createVisitors(context, {
       Document(node) {
-        // @ts-ignore
-        checkSiblings(node.children);
+        checkChildren(node.children, node);
       },
     });
   },

package/lib/rules/id-naming-convention.js

@@ -1,8 +1,14 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").ScriptTag } ScriptTag
- * @typedef { import("../types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ *
+ * @typedef {"camelCase" | "snake_case" | "PascalCase" | "kebab-case" | "regex"} Option1
+ * @typedef {Object} Option2
+ * @property {string} pattern
+ * @property {string} [flags]
+ *
+ * @typedef { import("../types").RuleModule<[Option1, Option2]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");

package/lib/rules/indent/indent-level.js

@@ -1,5 +1,5 @@
 /**
- * @typedef {import("../../types").AnyNode} AnyNode
+ * @typedef {import("@html-eslint/types").AnyNode} AnyNode
  * @typedef {{ [key in AnyNode['type']]?: number}} IncLevelOptions
  * @typedef {(node: AnyNode) => number} GetIncreasingLevel
  */

package/lib/rules/indent/indent.js

@@ -1,18 +1,19 @@
 /**
- * @typedef { import("../../types").RuleModule } RuleModule
- * @typedef { import("../../types").AnyNode } AnyNode
+ * @typedef { import("@html-eslint/types").AnyNode } AnyNode
  * @typedef { import("../../types").Line } Line
- * @typedef { import("../../types").Tag } Tag
+ * @typedef { import("@html-eslint/types").Tag } Tag
  * @typedef { import("../../types").RuleListener } RuleListener
- * @typedef { import("../../types").Context } Context
- * @typedef { import("../../types").TemplateText } TemplateText
+ * @typedef { import("../../types").Context<any[]> } Context
+ * @typedef { import("@html-eslint/types").TemplateText } TemplateText
  * @typedef { import("eslint").AST.Token } Token
  * @typedef { import("eslint").SourceCode } SourceCode
  * @typedef { import("eslint").AST.Range } Range
  * @typedef { import("eslint").AST.SourceLocation } SourceLocation
- * @typedef { import("../../types").TemplateLiteral } TemplateLiteral
- *
+ * @typedef { import("@html-eslint/types").TemplateLiteral } TemplateLiteral
+ * @typedef { import("@html-eslint/types").OpenTemplate } OpenTemplate
+ * @typedef { import("@html-eslint/types").CloseTemplate } CloseTemplate
  *
+ * @typedef {AnyNode | Line} AnyNodeOrLine
  * @typedef {Object} IndentType
  * @property {"tab"} TAB
  * @property {"space"} SPACE
@@ -22,6 +23,13 @@
  * @property {IndentType["TAB"] | IndentType["SPACE"]} indentType
  * @property {number} indentSize
  * @property {string} indentChar
+ *
+ * @typedef {"tab" | number} Option1
+ * @typedef {Object} Option2
+ * @property {number} [Option2.Attribute]
+ * @property {Record<string, number>} [Option2.tagChildrenIndent]
+ *
+ * @typedef { import("../../types").RuleModule<[Option1, Option2]> } RuleModule
  */
 
 const { parse } = require("@html-eslint/template-parser");
@@ -145,9 +153,14 @@ module.exports = {
       if (isTag(node)) {
         return getTagIncreasingLevel(node);
       }
-      return typeof indentLevelOptions[node.type] === "number"
-        ? indentLevelOptions[node.type]
-        : 1;
+      const type = node.type;
+      if (type === NodeTypes.Attribute) {
+        const optionIndent = indentLevelOptions[type];
+        if (typeof optionIndent === "number") {
+          return optionIndent;
+        }
+      }
+      return 1;
     }
 
     /**
@@ -180,7 +193,7 @@ module.exports = {
       let parentIgnoringChildCount = 0;
 
       /**
-       * @param {AnyNode | Line | TemplateText} node
+       * @param {AnyNode | Line | TemplateText | OpenTemplate | CloseTemplate} node
        * @returns {string}
        */
       function getActualIndent(node) {
@@ -235,7 +248,7 @@ module.exports = {
       }
 
       /**
-       * @param {AnyNode | Line | TemplateText} node
+       * @param {AnyNode | Line | TemplateText | OpenTemplate | CloseTemplate} node
        */
       function checkIndent(node) {
         if (parentIgnoringChildCount > 0) {
@@ -250,11 +263,11 @@ module.exports = {
         if (actualIndent !== expectedIndent) {
           const targetNode = getIndentNodeToReport(node, actualIndent);
           context.report({
-            node: targetNode,
+            loc: targetNode.loc,
             messageId: MESSAGE_ID.WRONG_INDENT,
             data: getMessageData(actualIndent, indentLevel.value()),
             fix(fixer) {
-              return fixer.replaceText(targetNode, expectedIndent);
+              return fixer.replaceTextRange(targetNode.range, expectedIndent);
             },
           });
         }
@@ -396,7 +409,7 @@ module.exports = {
 };
 
 /**
- * @param {AnyNode | Line | TemplateText} node
+ * @param {AnyNodeOrLine | TemplateText | OpenTemplate | CloseTemplate} node
  * @param {string} actualIndent
  * @return {{range: Range; loc: SourceLocation}}
  */

package/lib/rules/lowercase.js

@@ -1,8 +1,8 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("../types").RuleModule<[]> } RuleModule
  */
 
 const { NODE_TYPES } = require("@html-eslint/parser");

package/lib/rules/max-element-depth.js

@@ -1,8 +1,11 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ *
+ * @typedef {Object} Option
+ * @property {number} [Option.max]
+ * @typedef { import("../types").RuleModule<[Option]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");
@@ -71,7 +74,7 @@ module.exports = {
           node,
           messageId: MESSAGE_IDS.MAX_DEPTH_EXCEEDED,
           data: {
-            needed: maxDepth,
+            needed: `${maxDepth}`,
             found: String(depth),
           },
         });

package/lib/rules/no-abstract-roles.js

@@ -1,8 +1,8 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("../types").RuleModule<[]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");

package/lib/rules/no-accesskey-attrs.js

@@ -1,8 +1,8 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("../types").RuleModule<[]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");

package/lib/rules/no-aria-hidden-body.js

@@ -1,5 +1,5 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
+ * @typedef { import("../types").RuleModule<[]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");

package/lib/rules/no-duplicate-attrs.js

@@ -1,8 +1,8 @@
 /**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").Tag } Tag
- * @typedef { import("../types").StyleTag } StyleTag
- * @typedef { import("../types").ScriptTag } ScriptTag
+ * @typedef { import("@html-eslint/types").Tag } Tag
+ * @typedef { import("@html-eslint/types").StyleTag } StyleTag
+ * @typedef { import("@html-eslint/types").ScriptTag } ScriptTag
+ * @typedef { import("../types").RuleModule<[]> } RuleModule
  */
 
 const { RULE_CATEGORY } = require("../constants");