@html-eslint/eslint-plugin 0.30.0 → 0.31.1-alpha.0

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

@@ -0,0 +1,61 @@
+/**
+ * @typedef {import("../../types").AnyNode} AnyNode
+ * @typedef {{ [key in AnyNode['type']]?: number}} IncLevelOptions
+ * @typedef {(node: AnyNode) => number} GetIncreasingLevel
+ */
+
+class IndentLevel {
+  /**
+   * @param {Object} config
+   * @param {GetIncreasingLevel} config.getIncreasingLevel
+   */
+  constructor(config) {
+    /**
+     * @member
+     * @private
+     * @type {number}
+     */
+    this.level = -1;
+    /**
+     * @member
+     * @private
+     * @type {number}
+     */
+    this.baseLevel = 0;
+    /**
+     * @member
+     * @private
+     */
+    this.getInc = config.getIncreasingLevel;
+  }
+
+  /**
+   * @returns {number}
+   */
+  value() {
+    return this.level + this.baseLevel;
+  }
+
+  /**
+   * @param {AnyNode} node
+   */
+  indent(node) {
+    this.level += this.getInc(node);
+  }
+
+  /**
+   * @param {AnyNode} node
+   */
+  dedent(node) {
+    this.level -= this.getInc(node);
+  }
+
+  /**
+   * @param {number} base
+   */
+  setBase(base) {
+    this.baseLevel = base;
+  }
+}
+
+module.exports = IndentLevel;

package/lib/rules/indent/indent.js

@@ -0,0 +1,369 @@
+/**
+ * @typedef { import("../../types").RuleModule } RuleModule
+ * @typedef { import("../../types").AnyNode } AnyNode
+ * @typedef { import("../../types").LineNode } LineNode
+ * @typedef { import("../../types").BaseNode } BaseNode
+ * @typedef { import("../../types").TagNode } TagNode
+ * @typedef { import("../../types").RuleListener } RuleListener
+ * @typedef { import("eslint").AST.Token } Token
+ * @typedef { import("eslint").SourceCode } SourceCode
+ * @typedef { import("estree").TemplateLiteral } TemplateLiteral
+ * @typedef {Object} IndentType
+ * @property {"tab"} TAB
+ * @property {"space"} SPACE
+ * @typedef {Object} MessageId
+ * @property {"wrongIndent"} WRONG_INDENT
+ */
+
+const { parse } = require("@html-eslint/template-parser");
+const { RULE_CATEGORY } = require("../../constants");
+const { splitToLineNodes } = require("../utils/node");
+const {
+  shouldCheckTaggedTemplateExpression,
+  shouldCheckTemplateLiteral,
+} = require("../utils/settings");
+const { getSourceCode } = require("../utils/source-code");
+const IndentLevel = require("./indent-level");
+
+/** @type {MessageId} */
+const MESSAGE_ID = {
+  WRONG_INDENT: "wrongIndent",
+};
+
+/** @type {IndentType} */
+const INDENT_TYPES = {
+  TAB: "tab",
+  SPACE: "space",
+};
+
+const IGNORING_NODES = ["pre", "xmp"];
+
+/**
+ * @type {RuleModule}
+ */
+module.exports = {
+  meta: {
+    type: "code",
+
+    docs: {
+      description: "Enforce consistent indentation",
+      category: RULE_CATEGORY.STYLE,
+      recommended: true,
+    },
+
+    fixable: true,
+    schema: [
+      {
+        oneOf: [
+          {
+            enum: ["tab"],
+          },
+          {
+            type: "integer",
+            minimum: 0,
+          },
+        ],
+      },
+      {
+        type: "object",
+        properties: {
+          Attribute: {
+            type: "integer",
+            minimum: 1,
+            default: 1,
+          },
+        },
+      },
+    ],
+    messages: {
+      [MESSAGE_ID.WRONG_INDENT]:
+        "Expected indentation of {{expected}} but found {{actual}}.",
+    },
+  },
+  create(context) {
+    const sourceCode = getSourceCode(context);
+    const indentLevelOptions = (context.options && context.options[1]) || {};
+    const lines = sourceCode.getLines();
+    const { indentType, indentSize, indentChar } = (function () {
+      const options = context.options;
+      /**
+       * @type {IndentType['SPACE'] | IndentType['TAB']}
+       */
+      let indentType = INDENT_TYPES.SPACE;
+      let indentSize = 4;
+      if (options.length) {
+        if (options[0] === INDENT_TYPES.TAB) {
+          indentType = INDENT_TYPES.TAB;
+        } else {
+          indentSize = options[0];
+        }
+      }
+      const indentChar =
+        indentType === INDENT_TYPES.SPACE ? " ".repeat(indentSize) : "\t";
+      return { indentType, indentSize, indentChar };
+    })();
+
+    /**
+     * @param {string} str
+     * @returns {number}
+     */
+    function countLeftPadding(str) {
+      return str.length - str.replace(/^[\s\t]+/, "").length;
+    }
+
+    /**
+     * @param {AnyNode} node
+     * @returns {node is LineNode}
+     */
+    function isLineNode(node) {
+      return node.type === "Line";
+    }
+
+    /**
+     *
+     * @param {TemplateLiteral} node
+     * @returns {number}
+     */
+    function getTemplateLiteralBaseIndentLevel(node) {
+      // @ts-ignore
+      const lineIndex = node.loc.start.line - 1;
+      const line = lines[lineIndex];
+
+      const spaceCount = countLeftPadding(line);
+      if (indentType === "space") {
+        return Math.floor(spaceCount / indentSize) + 1;
+      } else {
+        return spaceCount + 1;
+      }
+    }
+
+    /**
+     * @param {number} baseLevel
+     */
+    function createIndentVisitor(baseLevel) {
+      const indentLevel = new IndentLevel({
+        getIncreasingLevel(node) {
+          return typeof indentLevelOptions[node.type] === "number"
+            ? indentLevelOptions[node.type]
+            : 1;
+        },
+      });
+      indentLevel.setBase(baseLevel);
+
+      let parentIgnoringChildCount = 0;
+
+      /**
+       * @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;
+
+        if (isLineNode(node)) {
+          column += countLeftPadding(node.value);
+        }
+
+        return line.slice(0, column);
+      }
+
+      /**
+       * @returns {string}
+       */
+      function getExpectedIndent() {
+        return indentChar.repeat(indentLevel.value());
+      }
+
+      /**
+       * @param {AnyNode} node
+       * @param {string} actualIndent
+       * @return {BaseNode}
+       */
+      function getIndentNodeToReport(node, actualIndent) {
+        let rangeStart = node.range[0];
+
+        if (node.type !== "Line") {
+          rangeStart -= actualIndent.length;
+        }
+
+        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 {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 (indentType === "space") {
+          expectedIndentSize *= indentSize;
+        }
+
+        return {
+          actual,
+          expected: `${expectedIndentSize} ${indentType}`,
+        };
+      }
+
+      /**
+       * @param {AnyNode} node
+       */
+      function checkIndent(node) {
+        if (parentIgnoringChildCount > 0) {
+          return;
+        }
+        const actualIndent = getActualIndent(node);
+        const expectedIndent = getExpectedIndent();
+
+        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);
+            },
+          });
+        }
+      }
+
+      /**
+       * @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--;
+          }
+          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 {
+      ...createIndentVisitor(0),
+      TaggedTemplateExpression(node) {
+        if (shouldCheckTaggedTemplateExpression(node, context)) {
+          const base = getTemplateLiteralBaseIndentLevel(node.quasi);
+          parse(node.quasi, getSourceCode(context), createIndentVisitor(base));
+        }
+      },
+      TemplateLiteral(node) {
+        if (shouldCheckTemplateLiteral(node, context)) {
+          const base = getTemplateLiteralBaseIndentLevel(node);
+          parse(node, getSourceCode(context), createIndentVisitor(base));
+        }
+      },
+    };
+  },
+};

package/lib/rules/indent/index.js

@@ -0,0 +1,2 @@
+const indent = require("./indent");
+module.exports = indent;

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.30.0",
+  "version": "0.31.1-alpha.0",
   "description": "ESLint plugin for html",
   "author": "yeonjuan",
   "homepage": "https://github.com/yeonjuan/html-eslint#readme",
@@ -45,15 +45,15 @@
     "accessibility"
   ],
   "dependencies": {
-    "@html-eslint/template-parser": "^0.30.0"
+    "@html-eslint/template-parser": "^0.31.0"
   },
   "devDependencies": {
-    "@html-eslint/parser": "^0.30.0",
+    "@html-eslint/parser": "^0.31.0",
     "@types/eslint": "^9.6.1",
     "@types/estree": "^0.0.47",
     "es-html-parser": "^1.0.0-alpha.4",
     "espree": "^10.3.0",
     "typescript": "^5.7.2"
   },
-  "gitHead": "29f274f996d9cd41b82f2f2fa5c642564d3bc756"
+  "gitHead": "ae36c432e1500a56da5cc3aa1a26a8a40e8f2128"
 }

package/types/rules/indent/indent-level.d.ts

@@ -0,0 +1,55 @@
+export = IndentLevel;
+/**
+ * @typedef {import("../../types").AnyNode} AnyNode
+ * @typedef {{ [key in AnyNode['type']]?: number}} IncLevelOptions
+ * @typedef {(node: AnyNode) => number} GetIncreasingLevel
+ */
+declare class IndentLevel {
+    /**
+     * @param {Object} config
+     * @param {GetIncreasingLevel} config.getIncreasingLevel
+     */
+    constructor(config: {
+        getIncreasingLevel: GetIncreasingLevel;
+    });
+    /**
+     * @member
+     * @private
+     * @type {number}
+     */
+    private level;
+    /**
+     * @member
+     * @private
+     * @type {number}
+     */
+    private baseLevel;
+    /**
+     * @member
+     * @private
+     */
+    private getInc;
+    /**
+     * @returns {number}
+     */
+    value(): number;
+    /**
+     * @param {AnyNode} node
+     */
+    indent(node: AnyNode): void;
+    /**
+     * @param {AnyNode} node
+     */
+    dedent(node: AnyNode): void;
+    /**
+     * @param {number} base
+     */
+    setBase(base: number): void;
+}
+declare namespace IndentLevel {
+    export { AnyNode, IncLevelOptions, GetIncreasingLevel };
+}
+type AnyNode = import("../../types").AnyNode;
+type IncLevelOptions = { [key in AnyNode["type"]]?: number; };
+type GetIncreasingLevel = (node: AnyNode) => number;
+//# sourceMappingURL=indent-level.d.ts.map

package/types/rules/indent/indent-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indent-level.d.ts","sourceRoot":"","sources":["../../../lib/rules/indent/indent-level.js"],"names":[],"mappings":";AAAA;;;;GAIG;AAEH;IACE;;;OAGG;IACH,oBAFG;QAAmC,kBAAkB,EAA7C,kBAAkB;KAC5B,EAmBA;IAjBC;;;;OAIG;IACH,cAAe;IACf;;;;OAIG;IACH,kBAAkB;IAClB;;;OAGG;IACH,eAAuC;IAGzC;;OAEG;IACH,SAFa,MAAM,CAIlB;IAED;;OAEG;IACH,aAFW,OAAO,QAIjB;IAED;;OAEG;IACH,aAFW,OAAO,QAIjB;IAED;;OAEG;IACH,cAFW,MAAM,QAIhB;CACF;;;;eAzDY,OAAO,aAAa,EAAE,OAAO;uBAC7B,GAAG,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,GAAC;0BACpC,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM"}

package/types/rules/indent/indent.d.ts

@@ -0,0 +1,22 @@
+declare namespace _exports {
+    export { RuleModule, AnyNode, LineNode, BaseNode, TagNode, RuleListener, Token, SourceCode, TemplateLiteral, IndentType, MessageId };
+}
+declare const _exports: RuleModule;
+export = _exports;
+type RuleModule = import("../../types").RuleModule;
+type AnyNode = import("../../types").AnyNode;
+type LineNode = import("../../types").LineNode;
+type BaseNode = import("../../types").BaseNode;
+type TagNode = import("../../types").TagNode;
+type RuleListener = import("../../types").RuleListener;
+type Token = import("eslint").AST.Token;
+type SourceCode = import("eslint").SourceCode;
+type TemplateLiteral = import("estree").TemplateLiteral;
+type IndentType = {
+    TAB: "tab";
+    SPACE: "space";
+};
+type MessageId = {
+    WRONG_INDENT: "wrongIndent";
+};
+//# sourceMappingURL=indent.d.ts.map

package/types/rules/indent/indent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indent.d.ts","sourceRoot":"","sources":["../../../lib/rules/indent/indent.js"],"names":[],"mappings":";;;wBAyCU,UAAU;;kBAxCN,OAAO,aAAa,EAAE,UAAU;eAChC,OAAO,aAAa,EAAE,OAAO;gBAC7B,OAAO,aAAa,EAAE,QAAQ;gBAC9B,OAAO,aAAa,EAAE,QAAQ;eAC9B,OAAO,aAAa,EAAE,OAAO;oBAC7B,OAAO,aAAa,EAAE,YAAY;aAClC,OAAO,QAAQ,EAAE,GAAG,CAAC,KAAK;kBAC1B,OAAO,QAAQ,EAAE,UAAU;uBAC3B,OAAO,QAAQ,EAAE,eAAe;;SAEhC,KAAK;WACL,OAAO;;;kBAEP,aAAa"}

package/types/rules/indent/index.d.ts

@@ -0,0 +1,3 @@
+export = indent;
+import indent = require("./indent");
+//# sourceMappingURL=index.d.ts.map

package/types/rules/indent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/rules/indent/index.js"],"names":[],"mappings":""}

package/types/rules/indent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indent.d.ts","sourceRoot":"","sources":["../../lib/rules/indent.js"],"names":[],"mappings":";;;wBAwCU,UAAU;;kBAvCN,OAAO,UAAU,EAAE,UAAU;eAC7B,OAAO,UAAU,EAAE,OAAO;gBAC1B,OAAO,UAAU,EAAE,QAAQ;gBAC3B,OAAO,UAAU,EAAE,QAAQ;eAC3B,OAAO,UAAU,EAAE,OAAO;oBAC1B,OAAO,UAAU,EAAE,YAAY;aAC/B,OAAO,QAAQ,EAAE,GAAG,CAAC,KAAK;kBAC1B,OAAO,QAAQ,EAAE,UAAU;uBAC3B,OAAO,QAAQ,EAAE,eAAe;;SAEhC,KAAK;WACL,OAAO;;;kBAEP,aAAa"}
+{"version":3,"file":"indent.d.ts","sourceRoot":"","sources":["../../lib/rules/indent.js"],"names":[],"mappings":";;;wBAyCU,UAAU;;kBAxCN,OAAO,UAAU,EAAE,UAAU;eAC7B,OAAO,UAAU,EAAE,OAAO;gBAC1B,OAAO,UAAU,EAAE,QAAQ;gBAC3B,OAAO,UAAU,EAAE,QAAQ;eAC3B,OAAO,UAAU,EAAE,OAAO;oBAC1B,OAAO,UAAU,EAAE,YAAY;aAC/B,OAAO,QAAQ,EAAE,GAAG,CAAC,KAAK;kBAC1B,OAAO,QAAQ,EAAE,UAAU;uBAC3B,OAAO,QAAQ,EAAE,eAAe;;SAEhC,KAAK;WACL,OAAO;;;kBAEP,aAAa"}

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"}

package/lib/rules/indent.js

@@ -1,378 +0,0 @@
-/**
- * @typedef { import("../types").RuleModule } RuleModule
- * @typedef { import("../types").AnyNode } AnyNode
- * @typedef { import("../types").LineNode } LineNode
- * @typedef { import("../types").BaseNode } BaseNode
- * @typedef { import("../types").TagNode } TagNode
- * @typedef { import("../types").RuleListener } RuleListener
- * @typedef { import("eslint").AST.Token } Token
- * @typedef { import("eslint").SourceCode } SourceCode
- * @typedef { import("estree").TemplateLiteral } TemplateLiteral
- * @typedef {Object} IndentType
- * @property {"tab"} TAB
- * @property {"space"} SPACE
- * @typedef {Object} MessageId
- * @property {"wrongIndent"} WRONG_INDENT
- */
-
-const { parse } = require("@html-eslint/template-parser");
-const { RULE_CATEGORY } = require("../constants");
-const { splitToLineNodes } = require("./utils/node");
-const {
-  shouldCheckTaggedTemplateExpression,
-  shouldCheckTemplateLiteral,
-} = require("./utils/settings");
-const { getSourceCode } = require("./utils/source-code");
-
-/** @type {MessageId} */
-const MESSAGE_ID = {
-  WRONG_INDENT: "wrongIndent",
-};
-
-/** @type {IndentType} */
-const INDENT_TYPES = {
-  TAB: "tab",
-  SPACE: "space",
-};
-
-const IGNORING_NODES = ["pre", "xmp"];
-
-/**
- * @type {RuleModule}
- */
-module.exports = {
-  meta: {
-    type: "code",
-
-    docs: {
-      description: "Enforce consistent indentation",
-      category: RULE_CATEGORY.STYLE,
-      recommended: true,
-    },
-
-    fixable: true,
-    schema: [
-      {
-        oneOf: [
-          {
-            enum: ["tab"],
-          },
-          {
-            type: "integer",
-            minimum: 0,
-          },
-        ],
-      },
-    ],
-    messages: {
-      [MESSAGE_ID.WRONG_INDENT]:
-        "Expected indentation of {{expected}} but found {{actual}}.",
-    },
-  },
-  create(context) {
-    const sourceCode = getSourceCode(context);
-
-    let baseIndentLevel = 0;
-    let indentLevel = -1;
-    let parentIgnoringChildCount = 0;
-
-    const { indentType, indentSize, indentChar } = (function () {
-      const options = context.options;
-      /**
-       * @type {IndentType['SPACE'] | IndentType['TAB']}
-       */
-      let indentType = INDENT_TYPES.SPACE;
-      let indentSize = 4;
-      if (options.length) {
-        if (options[0] === INDENT_TYPES.TAB) {
-          indentType = INDENT_TYPES.TAB;
-        } else {
-          indentSize = options[0];
-        }
-      }
-      const indentChar =
-        indentType === INDENT_TYPES.SPACE ? " ".repeat(indentSize) : "\t";
-      return { indentType, indentSize, indentChar };
-    })();
-
-    function indent() {
-      indentLevel++;
-    }
-    function unindent() {
-      indentLevel--;
-    }
-    function getIndentLevel() {
-      return indentLevel + baseIndentLevel;
-    }
-
-    /**
-     * @param {string} str
-     * @returns {number}
-     */
-    function countLeftPadding(str) {
-      return str.length - str.replace(/^[\s\t]+/, "").length;
-    }
-
-    /**
-     * @param {AnyNode} node
-     * @returns {node is LineNode}
-     */
-    function isLineNode(node) {
-      return node.type === "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;
-
-      if (isLineNode(node)) {
-        column += countLeftPadding(node.value);
-      }
-
-      return line.slice(0, column);
-    }
-
-    /**
-     * @returns {string}
-     */
-    function getExpectedIndent() {
-      return indentChar.repeat(getIndentLevel());
-    }
-
-    /**
-     * @param {AnyNode} node
-     * @param {string} actualIndent
-     * @return {BaseNode}
-     */
-    function getIndentNodeToReport(node, actualIndent) {
-      let rangeStart = node.range[0];
-
-      if (node.type !== "Line") {
-        rangeStart -= actualIndent.length;
-      }
-
-      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 {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 (indentType === "space") {
-        expectedIndentSize *= indentSize;
-      }
-
-      return {
-        actual,
-        expected: `${expectedIndentSize} ${indentType}`,
-      };
-    }
-
-    /**
-     * @param {AnyNode} node
-     */
-    function checkIndent(node) {
-      if (parentIgnoringChildCount > 0) {
-        return;
-      }
-      const actualIndent = getActualIndent(node);
-      const expectedIndent = getExpectedIndent();
-
-      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, getIndentLevel()),
-          fix(fixer) {
-            return fixer.replaceText(targetNode, expectedIndent);
-          },
-        });
-      }
-    }
-
-    /**
-     *
-     * @param {Token} token
-     */
-    function getBaseIndentToken(token) {
-      /**
-       * @type {Token | null}
-       */
-      let currentToken = token;
-      let tokenBefore = token;
-
-      while (
-        // @ts-ignore
-        (tokenBefore = sourceCode.getTokenBefore(currentToken, {
-          includeComments: true,
-        }))
-      ) {
-        if (!tokenBefore) {
-          return currentToken;
-        }
-        if (tokenBefore.loc.start.line !== currentToken.loc.start.line) {
-          return currentToken;
-        }
-        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;
-      }
-      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++;
-        }
-        indent();
-      },
-      ScriptTag: indent,
-      "ScriptTag:exit": unindent,
-      OpenScriptTagStart: checkIndent,
-      OpenScriptTagEnd: checkIndent,
-      StyleTag: indent,
-      "StyleTag:exit": unindent,
-      OpenStyleTagStart: checkIndent,
-      OpenStyleTagEnd: checkIndent,
-      OpenTagStart: checkIndent,
-      OpenTagEnd: checkIndent,
-      CloseTag: checkIndent,
-      /**
-       * @param {TagNode} node
-       */
-      "Tag:exit"(node) {
-        if (IGNORING_NODES.includes(node.name)) {
-          parentIgnoringChildCount--;
-        }
-        unindent();
-      },
-
-      // Attribute
-      Attribute: indent,
-      AttributeKey: checkIndent,
-      AttributeValue: checkIndent,
-      "Attribute:exit": unindent,
-
-      // Text
-      Text(node) {
-        indent();
-        const lineNodes = splitToLineNodes(node);
-        lineNodes.forEach((lineNode) => {
-          if (lineNode.skipIndentCheck) {
-            return;
-          }
-          if (lineNode.value.trim().length) {
-            checkIndent(lineNode);
-          }
-        });
-      },
-      "Text:exit": unindent,
-
-      // Comment
-      Comment: indent,
-      CommentOpen: checkIndent,
-      CommentContent(node) {
-        indent();
-        const lineNodes = splitToLineNodes(node);
-        lineNodes.forEach((lineNode) => {
-          if (lineNode.skipIndentCheck) {
-            return;
-          }
-          if (lineNode.value.trim().length) {
-            checkIndent(lineNode);
-          }
-        });
-      },
-      CommentClose: checkIndent,
-      "Comment:exit": unindent,
-      "CommentContent:exit": unindent,
-    };
-
-    return {
-      ...visitor,
-      TaggedTemplateExpression(node) {
-        if (shouldCheckTaggedTemplateExpression(node, context)) {
-          baseIndentLevel = getBaseIndentLevel(node.quasi) + 1;
-          parse(node.quasi, getSourceCode(context), visitor);
-        }
-      },
-      "TaggedTemplateExpression:exit"(node) {
-        if (shouldCheckTaggedTemplateExpression(node, context)) {
-          baseIndentLevel = 0;
-        }
-      },
-      TemplateLiteral(node) {
-        if (shouldCheckTemplateLiteral(node, context)) {
-          baseIndentLevel = getBaseIndentLevel(node) + 1;
-          parse(node, getSourceCode(context), visitor);
-        }
-      },
-      "TemplateLiteral:exit"(node) {
-        if (shouldCheckTemplateLiteral(node, context)) {
-          baseIndentLevel = 0;
-        }
-      },
-    };
-  },
-};