@html-eslint/eslint-plugin 0.31.0 → 0.31.1

package/lib/rules/indent/indent.js

@@ -83,16 +83,7 @@ module.exports = {
   create(context) {
     const sourceCode = getSourceCode(context);
     const indentLevelOptions = (context.options && context.options[1]) || {};
-    const indentLevel = new IndentLevel({
-      getIncreasingLevel(node) {
-        return typeof indentLevelOptions[node.type] === "number"
-          ? indentLevelOptions[node.type]
-          : 1;
-      },
-    });
-
-    let parentIgnoringChildCount = 0;
-
+    const lines = sourceCode.getLines();
     const { indentType, indentSize, indentChar } = (function () {
       const options = context.options;
       /**
@@ -129,270 +120,248 @@ module.exports = {
     }
 
     /**
-     * @param {AnyNode} node
-     * @returns {string}
+     *
+     * @param {TemplateLiteral} node
+     * @returns {number}
      */
-    function getActualIndent(node) {
-      const lines = sourceCode.getLines();
-      const line = lines[node.loc.start.line - 1];
-      let column = node.loc.start.column;
+    function getTemplateLiteralBaseIndentLevel(node) {
+      // @ts-ignore
+      const lineIndex = node.loc.start.line - 1;
+      const line = lines[lineIndex];
 
-      if (isLineNode(node)) {
-        column += countLeftPadding(node.value);
+      const spaceCount = countLeftPadding(line);
+      if (indentType === "space") {
+        return Math.floor(spaceCount / indentSize) + 1;
+      } else {
+        return spaceCount + 1;
       }
-
-      return line.slice(0, column);
     }
 
     /**
-     * @returns {string}
-     */
-    function getExpectedIndent() {
-      return indentChar.repeat(indentLevel.value());
-    }
-
-    /**
-     * @param {AnyNode} node
-     * @param {string} actualIndent
-     * @return {BaseNode}
+     * @param {number} baseLevel
      */
-    function getIndentNodeToReport(node, actualIndent) {
-      let rangeStart = node.range[0];
+    function createIndentVisitor(baseLevel) {
+      const indentLevel = new IndentLevel({
+        getIncreasingLevel(node) {
+          return typeof indentLevelOptions[node.type] === "number"
+            ? indentLevelOptions[node.type]
+            : 1;
+        },
+      });
+      indentLevel.setBase(baseLevel);
 
-      if (node.type !== "Line") {
-        rangeStart -= actualIndent.length;
-      }
+      let parentIgnoringChildCount = 0;
 
-      return {
-        range: [rangeStart, rangeStart + actualIndent.length],
-        loc: {
-          start: {
-            column: 0,
-            line: node.loc.start.line,
-          },
-          end: {
-            column: actualIndent.length,
-            line: node.loc.start.line,
-          },
-        },
-      };
-    }
+      /**
+       * @param {AnyNode} node
+       * @returns {string}
+       */
+      function getActualIndent(node) {
+        const lines = sourceCode.getLines();
+        const line = lines[node.loc.start.line - 1];
+        let column = node.loc.start.column;
 
-    /**
-     * @param {string} actualIndent
-     * @param {number} expectedIndentSize
-     */
-    function getMessageData(actualIndent, expectedIndentSize) {
-      const actualTabs = (actualIndent.match(/\t/g) || []).length;
-      const actualSpaces = (actualIndent.match(/[^\S\t\n\r]/g) || []).length;
-      let actual = "";
-      if (!actualTabs && !actualSpaces) {
-        actual = "no indent";
-      } else {
-        if (actualTabs) {
-          actual += `${actualTabs} tab`;
-        }
-        if (actualSpaces) {
-          if (actual) {
-            actual += ", ";
-          }
-          actual += `${actualSpaces} space`;
+        if (isLineNode(node)) {
+          column += countLeftPadding(node.value);
         }
+
+        return line.slice(0, column);
       }
 
-      if (indentType === "space") {
-        expectedIndentSize *= indentSize;
+      /**
+       * @returns {string}
+       */
+      function getExpectedIndent() {
+        return indentChar.repeat(indentLevel.value());
       }
 
-      return {
-        actual,
-        expected: `${expectedIndentSize} ${indentType}`,
-      };
-    }
+      /**
+       * @param {AnyNode} node
+       * @param {string} actualIndent
+       * @return {BaseNode}
+       */
+      function getIndentNodeToReport(node, actualIndent) {
+        let rangeStart = node.range[0];
 
-    /**
-     * @param {AnyNode} node
-     */
-    function checkIndent(node) {
-      if (parentIgnoringChildCount > 0) {
-        return;
-      }
-      const actualIndent = getActualIndent(node);
-      const expectedIndent = getExpectedIndent();
+        if (node.type !== "Line") {
+          rangeStart -= actualIndent.length;
+        }
 
-      if (actualIndent.trim().length) {
-        return;
-      }
-      if (actualIndent !== expectedIndent) {
-        const targetNode = getIndentNodeToReport(node, actualIndent);
-        context.report({
-          node: targetNode,
-          messageId: MESSAGE_ID.WRONG_INDENT,
-          data: getMessageData(actualIndent, indentLevel.value()),
-          fix(fixer) {
-            return fixer.replaceText(targetNode, expectedIndent);
+        return {
+          range: [rangeStart, rangeStart + actualIndent.length],
+          loc: {
+            start: {
+              column: 0,
+              line: node.loc.start.line,
+            },
+            end: {
+              column: actualIndent.length,
+              line: node.loc.start.line,
+            },
           },
-        });
+        };
       }
-    }
 
-    /**
-     *
-     * @param {Token} token
-     */
-    function getBaseIndentToken(token) {
       /**
-       * @type {Token | null}
+       * @param {string} actualIndent
+       * @param {number} expectedIndentSize
        */
-      let currentToken = token;
-      let tokenBefore = token;
-
-      while (
-        // @ts-ignore
-        (tokenBefore = sourceCode.getTokenBefore(currentToken, {
-          includeComments: true,
-        }))
-      ) {
-        if (!tokenBefore) {
-          return currentToken;
+      function getMessageData(actualIndent, expectedIndentSize) {
+        const actualTabs = (actualIndent.match(/\t/g) || []).length;
+        const actualSpaces = (actualIndent.match(/[^\S\t\n\r]/g) || []).length;
+        let actual = "";
+        if (!actualTabs && !actualSpaces) {
+          actual = "no indent";
+        } else {
+          if (actualTabs) {
+            actual += `${actualTabs} tab`;
+          }
+          if (actualSpaces) {
+            if (actual) {
+              actual += ", ";
+            }
+            actual += `${actualSpaces} space`;
+          }
         }
-        if (tokenBefore.loc.start.line !== currentToken.loc.start.line) {
-          return currentToken;
+
+        if (indentType === "space") {
+          expectedIndentSize *= indentSize;
         }
-        currentToken = tokenBefore;
-      }
-      return tokenBefore;
-    }
 
-    /**
-     *
-     * @param {TemplateLiteral} node
-     * @returns {number}
-     */
-    function getBaseIndentLevel(node) {
-      const firstToken = sourceCode.getFirstToken(node);
-      if (!firstToken) return 0;
-      const baseToken = getBaseIndentToken(firstToken);
-      if (!baseToken) {
-        return 0;
+        return {
+          actual,
+          expected: `${expectedIndentSize} ${indentType}`,
+        };
       }
-      const spaceCount = baseToken.loc.start.column;
 
-      if (indentType === "space") {
-        return Math.floor(spaceCount / indentSize);
-      } else {
-        return spaceCount;
-      }
-    }
-    /**
-     * @type {RuleListener}
-     */
-    const visitor = {
-      Tag(node) {
-        if (IGNORING_NODES.includes(node.name)) {
-          parentIgnoringChildCount++;
-        }
-        indentLevel.indent(node);
-      },
-      ScriptTag(node) {
-        indentLevel.indent(node);
-      },
-      "ScriptTag:exit"(node) {
-        indentLevel.dedent(node);
-      },
-      OpenScriptTagStart: checkIndent,
-      OpenScriptTagEnd: checkIndent,
-      StyleTag(node) {
-        indentLevel.indent(node);
-      },
-      "StyleTag:exit"(node) {
-        indentLevel.dedent(node);
-      },
-      OpenStyleTagStart: checkIndent,
-      OpenStyleTagEnd: checkIndent,
-      OpenTagStart: checkIndent,
-      OpenTagEnd: checkIndent,
-      CloseTag: checkIndent,
-      "Tag:exit"(node) {
-        if (IGNORING_NODES.includes(node.name)) {
-          parentIgnoringChildCount--;
+      /**
+       * @param {AnyNode} node
+       */
+      function checkIndent(node) {
+        if (parentIgnoringChildCount > 0) {
+          return;
         }
-        indentLevel.dedent(node);
-      },
+        const actualIndent = getActualIndent(node);
+        const expectedIndent = getExpectedIndent();
 
-      // Attribute
-      Attribute(node) {
-        indentLevel.indent(node);
-      },
-      AttributeKey: checkIndent,
-      AttributeValue: checkIndent,
-      "Attribute:exit"(node) {
-        indentLevel.dedent(node);
-      },
+        if (actualIndent.trim().length) {
+          return;
+        }
+        if (actualIndent !== expectedIndent) {
+          const targetNode = getIndentNodeToReport(node, actualIndent);
+          context.report({
+            node: targetNode,
+            messageId: MESSAGE_ID.WRONG_INDENT,
+            data: getMessageData(actualIndent, indentLevel.value()),
+            fix(fixer) {
+              return fixer.replaceText(targetNode, expectedIndent);
+            },
+          });
+        }
+      }
 
-      // Text
-      Text(node) {
-        indentLevel.indent(node);
-        const lineNodes = splitToLineNodes(node);
-        lineNodes.forEach((lineNode) => {
-          if (lineNode.skipIndentCheck) {
-            return;
-          }
-          if (lineNode.value.trim().length) {
-            checkIndent(lineNode);
-          }
-        });
-      },
-      "Text:exit"(node) {
-        indentLevel.dedent(node);
-      },
-      Comment(node) {
-        indentLevel.indent(node);
-      },
-      CommentOpen: checkIndent,
-      CommentContent(node) {
-        indentLevel.indent(node);
-        const lineNodes = splitToLineNodes(node);
-        lineNodes.forEach((lineNode) => {
-          if (lineNode.skipIndentCheck) {
-            return;
+      /**
+       * @type {RuleListener}
+       */
+      const visitor = {
+        Tag(node) {
+          if (IGNORING_NODES.includes(node.name)) {
+            parentIgnoringChildCount++;
           }
-          if (lineNode.value.trim().length) {
-            checkIndent(lineNode);
+          indentLevel.indent(node);
+        },
+        ScriptTag(node) {
+          indentLevel.indent(node);
+        },
+        "ScriptTag:exit"(node) {
+          indentLevel.dedent(node);
+        },
+        OpenScriptTagStart: checkIndent,
+        OpenScriptTagEnd: checkIndent,
+        StyleTag(node) {
+          indentLevel.indent(node);
+        },
+        "StyleTag:exit"(node) {
+          indentLevel.dedent(node);
+        },
+        OpenStyleTagStart: checkIndent,
+        OpenStyleTagEnd: checkIndent,
+        OpenTagStart: checkIndent,
+        OpenTagEnd: checkIndent,
+        CloseTag: checkIndent,
+        "Tag:exit"(node) {
+          if (IGNORING_NODES.includes(node.name)) {
+            parentIgnoringChildCount--;
           }
-        });
-      },
-      CommentClose: checkIndent,
-      "Comment:exit"(node) {
-        indentLevel.dedent(node);
-      },
-      "CommentContent:exit"(node) {
-        indentLevel.dedent(node);
-      },
-    };
+          indentLevel.dedent(node);
+        },
+
+        // Attribute
+        Attribute(node) {
+          indentLevel.indent(node);
+        },
+        AttributeKey: checkIndent,
+        AttributeValue: checkIndent,
+        "Attribute:exit"(node) {
+          indentLevel.dedent(node);
+        },
+
+        // Text
+        Text(node) {
+          indentLevel.indent(node);
+          const lineNodes = splitToLineNodes(node);
+
+          lineNodes.forEach((lineNode) => {
+            if (lineNode.skipIndentCheck) {
+              return;
+            }
+            if (lineNode.value.trim().length) {
+              checkIndent(lineNode);
+            }
+          });
+        },
+        "Text:exit"(node) {
+          indentLevel.dedent(node);
+        },
+        Comment(node) {
+          indentLevel.indent(node);
+        },
+        CommentOpen: checkIndent,
+        CommentContent(node) {
+          indentLevel.indent(node);
+          const lineNodes = splitToLineNodes(node);
+          lineNodes.forEach((lineNode) => {
+            if (lineNode.skipIndentCheck) {
+              return;
+            }
+            if (lineNode.value.trim().length) {
+              checkIndent(lineNode);
+            }
+          });
+        },
+        CommentClose: checkIndent,
+        "Comment:exit"(node) {
+          indentLevel.dedent(node);
+        },
+        "CommentContent:exit"(node) {
+          indentLevel.dedent(node);
+        },
+      };
+      return visitor;
+    }
 
     return {
-      ...visitor,
+      ...createIndentVisitor(0),
       TaggedTemplateExpression(node) {
         if (shouldCheckTaggedTemplateExpression(node, context)) {
-          indentLevel.setBase(getBaseIndentLevel(node.quasi) + 1);
-          parse(node.quasi, getSourceCode(context), visitor);
-        }
-      },
-      "TaggedTemplateExpression:exit"(node) {
-        if (shouldCheckTaggedTemplateExpression(node, context)) {
-          indentLevel.setBase(0);
+          const base = getTemplateLiteralBaseIndentLevel(node.quasi);
+          parse(node.quasi, getSourceCode(context), createIndentVisitor(base));
         }
       },
       TemplateLiteral(node) {
         if (shouldCheckTemplateLiteral(node, context)) {
-          indentLevel.setBase(getBaseIndentLevel(node) + 1);
-          parse(node, getSourceCode(context), visitor);
-        }
-      },
-      "TemplateLiteral:exit"(node) {
-        if (shouldCheckTemplateLiteral(node, context)) {
-          indentLevel.setBase(0);
+          const base = getTemplateLiteralBaseIndentLevel(node);
+          parse(node, getSourceCode(context), createIndentVisitor(base));
         }
       },
     };

package/lib/rules/utils/node.js

@@ -86,30 +86,10 @@ function splitToLineNodes(node) {
    * @param {import("../../types").Range} range
    */
   function shouldSkipIndentCheck(range) {
-    const overlappedTemplates = templates.filter(
+    return templates.some(
       (template) =>
         template.isTemplate && isRangesOverlap(template.range, range)
     );
-
-    const isLineInTemplate = overlappedTemplates.some((template) => {
-      return template.range[0] <= range[0] && template.range[1] >= range[1];
-    });
-    if (isLineInTemplate) {
-      return true;
-    }
-    const isLineBeforeTemplate = overlappedTemplates.some((template) => {
-      return template.range[0] <= range[0] && template.range[1] <= range[1];
-    });
-    if (isLineBeforeTemplate) {
-      return true;
-    }
-    const isLineAfterTemplate = overlappedTemplates.some((template) => {
-      return template.range[1] <= range[0];
-    });
-    if (isLineAfterTemplate) {
-      return true;
-    }
-    return false;
   }
 
   node.value.split("\n").forEach((value, index) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "ESLint plugin for html",
   "author": "yeonjuan",
   "homepage": "https://github.com/yeonjuan/html-eslint#readme",
@@ -55,5 +55,5 @@
     "espree": "^10.3.0",
     "typescript": "^5.7.2"
   },
-  "gitHead": "0e9ece917af191d223ccec4b17d9096f02a96508"
+  "gitHead": "96d3cb165f2d777d36e7efbba174e46f437faec0"
 }

package/types/rules/utils/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../lib/rules/utils/node.js"],"names":[],"mappings":"sBACc,OAAO,gBAAgB,EAAE,OAAO;4BAChC,OAAO,gBAAgB,EAAE,aAAa;2BACtC,OAAO,gBAAgB,EAAE,YAAY;4BACrC,OAAO,gBAAgB,EAAE,aAAa;iCACtC,OAAO,gBAAgB,EAAE,kBAAkB;sBAC3C,OAAO,gBAAgB,EAAE,OAAO;uBAChC,OAAO,gBAAgB,EAAE,QAAQ;iCACjC,OAAO,gBAAgB,EAAE,kBAAkB;0BAC3C,OAAO,gBAAgB,EAAE,WAAW;uBACpC,OAAO,gBAAgB,EAAE,QAAQ;uBACjC,OAAO,aAAa,EAAE,QAAQ;uBAC9B,OAAO,aAAa,EAAE,QAAQ;uBAC9B,OAAO,aAAa,EAAE,QAAQ;oBAC9B,OAAO,aAAa,EAAE,KAAK;AAKzC;;;;GAIG;AACH,+BAJW,OAAO,GAAG,aAAa,GAAG,YAAY,OACtC,MAAM,GACJ,aAAa,GAAG,SAAS,CAMrC;AAED;;;;GAIG;AACH,wCAHW,OAAO,GAAG,aAAa,GAAG,YAAY,GACpC,OAAO,CAInB;AAED;;;;GAIG;AACH,6CAHW,OAAO,GACL,OAAO,CAInB;AAuBD;;;;GAIG;AACH,uCAHW,QAAQ,GAAG,kBAAkB,GAC3B,QAAQ,EAAE,CA4EtB;AAED;;;;;GAKG;AACH,sCAJW,QAAQ,SACR,QAAQ,GACN,QAAQ,CAOpB;AAED;;;GAGG;AACH,6CAHW,kBAAkB,GACjB,OAAO,CAOlB;AAED;;;GAGG;AACH,4BAHW,OAAO,GACL,IAAI,IAAI,OAAO,CAI3B;AAED;;;GAGG;AACH,gCAHW,OAAO,GACL,IAAI,IAAI,WAAW,CAI/B;AAED;;;GAGG;AACH,6BAHW,OAAO,GACL,IAAI,IAAI,QAAQ,CAI5B;AA1ID;;;;GAIG;AACH,kDAJW,CAAC,QAAQ,GAAG,kBAAkB,CAAC,CAAC,WAAW,CAAC,SAC5C,KAAK,GACH,OAAO,CAMnB;AAqID;;;GAGG;AACH,oCAHW,MAAM,GACJ,MAAM,EAAE,CAIpB;AA9JD;;;;;GAKG;AACH,wCAJW,KAAK,UACL,KAAK,GACH,OAAO,CAInB;AAwJD;;;;GAIG;AACH,0CAHW,QAAQ,EAAE,GACR,CAAC,CAAC,kBAAkB,GAAG,QAAQ,CAAC,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAapE"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../lib/rules/utils/node.js"],"names":[],"mappings":"sBACc,OAAO,gBAAgB,EAAE,OAAO;4BAChC,OAAO,gBAAgB,EAAE,aAAa;2BACtC,OAAO,gBAAgB,EAAE,YAAY;4BACrC,OAAO,gBAAgB,EAAE,aAAa;iCACtC,OAAO,gBAAgB,EAAE,kBAAkB;sBAC3C,OAAO,gBAAgB,EAAE,OAAO;uBAChC,OAAO,gBAAgB,EAAE,QAAQ;iCACjC,OAAO,gBAAgB,EAAE,kBAAkB;0BAC3C,OAAO,gBAAgB,EAAE,WAAW;uBACpC,OAAO,gBAAgB,EAAE,QAAQ;uBACjC,OAAO,aAAa,EAAE,QAAQ;uBAC9B,OAAO,aAAa,EAAE,QAAQ;uBAC9B,OAAO,aAAa,EAAE,QAAQ;oBAC9B,OAAO,aAAa,EAAE,KAAK;AAKzC;;;;GAIG;AACH,+BAJW,OAAO,GAAG,aAAa,GAAG,YAAY,OACtC,MAAM,GACJ,aAAa,GAAG,SAAS,CAMrC;AAED;;;;GAIG;AACH,wCAHW,OAAO,GAAG,aAAa,GAAG,YAAY,GACpC,OAAO,CAInB;AAED;;;;GAIG;AACH,6CAHW,OAAO,GACL,OAAO,CAInB;AAuBD;;;;GAIG;AACH,uCAHW,QAAQ,GAAG,kBAAkB,GAC3B,QAAQ,EAAE,CAwDtB;AAED;;;;;GAKG;AACH,sCAJW,QAAQ,SACR,QAAQ,GACN,QAAQ,CAOpB;AAED;;;GAGG;AACH,6CAHW,kBAAkB,GACjB,OAAO,CAOlB;AAED;;;GAGG;AACH,4BAHW,OAAO,GACL,IAAI,IAAI,OAAO,CAI3B;AAED;;;GAGG;AACH,gCAHW,OAAO,GACL,IAAI,IAAI,WAAW,CAI/B;AAED;;;GAGG;AACH,6BAHW,OAAO,GACL,IAAI,IAAI,QAAQ,CAI5B;AAtHD;;;;GAIG;AACH,kDAJW,CAAC,QAAQ,GAAG,kBAAkB,CAAC,CAAC,WAAW,CAAC,SAC5C,KAAK,GACH,OAAO,CAMnB;AAiHD;;;GAGG;AACH,oCAHW,MAAM,GACJ,MAAM,EAAE,CAIpB;AA1ID;;;;;GAKG;AACH,wCAJW,KAAK,UACL,KAAK,GACH,OAAO,CAInB;AAoID;;;;GAIG;AACH,0CAHW,QAAQ,EAAE,GACR,CAAC,CAAC,kBAAkB,GAAG,QAAQ,CAAC,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAapE"}