@html-eslint/eslint-plugin 0.30.0-alpha.0 → 0.31.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.js → indent/indent.js}

@@ -1,10 +1,10 @@
 /**
- * @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("../../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
@@ -16,13 +16,14 @@
  */
 
 const { parse } = require("@html-eslint/template-parser");
-const { RULE_CATEGORY } = require("../constants");
-const { splitToLineNodes } = require("./utils/node");
+const { RULE_CATEGORY } = require("../../constants");
+const { splitToLineNodes } = require("../utils/node");
 const {
   shouldCheckTaggedTemplateExpression,
   shouldCheckTemplateLiteral,
-} = require("./utils/settings");
-const { getSourceCode } = require("./utils/source-code");
+} = require("../utils/settings");
+const { getSourceCode } = require("../utils/source-code");
+const IndentLevel = require("./indent-level");
 
 /** @type {MessageId} */
 const MESSAGE_ID = {
@@ -63,6 +64,16 @@ module.exports = {
           },
         ],
       },
+      {
+        type: "object",
+        properties: {
+          Attribute: {
+            type: "integer",
+            minimum: 1,
+            default: 1,
+          },
+        },
+      },
     ],
     messages: {
       [MESSAGE_ID.WRONG_INDENT]:
@@ -71,9 +82,15 @@ 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 baseIndentLevel = 0;
-    let indentLevel = -1;
     let parentIgnoringChildCount = 0;
 
     const { indentType, indentSize, indentChar } = (function () {
@@ -95,16 +112,6 @@ module.exports = {
       return { indentType, indentSize, indentChar };
     })();
 
-    function indent() {
-      indentLevel++;
-    }
-    function unindent() {
-      indentLevel--;
-    }
-    function getIndentLevel() {
-      return indentLevel + baseIndentLevel;
-    }
-
     /**
      * @param {string} str
      * @returns {number}
@@ -141,7 +148,7 @@ module.exports = {
      * @returns {string}
      */
     function getExpectedIndent() {
-      return indentChar.repeat(getIndentLevel());
+      return indentChar.repeat(indentLevel.value());
     }
 
     /**
@@ -221,7 +228,7 @@ module.exports = {
         context.report({
           node: targetNode,
           messageId: MESSAGE_ID.WRONG_INDENT,
-          data: getMessageData(actualIndent, getIndentLevel()),
+          data: getMessageData(actualIndent, indentLevel.value()),
           fix(fixer) {
             return fixer.replaceText(targetNode, expectedIndent);
           },
@@ -285,38 +292,47 @@ module.exports = {
         if (IGNORING_NODES.includes(node.name)) {
           parentIgnoringChildCount++;
         }
-        indent();
+        indentLevel.indent(node);
+      },
+      ScriptTag(node) {
+        indentLevel.indent(node);
+      },
+      "ScriptTag:exit"(node) {
+        indentLevel.dedent(node);
       },
-      ScriptTag: indent,
-      "ScriptTag:exit": unindent,
       OpenScriptTagStart: checkIndent,
       OpenScriptTagEnd: checkIndent,
-      StyleTag: indent,
-      "StyleTag:exit": unindent,
+      StyleTag(node) {
+        indentLevel.indent(node);
+      },
+      "StyleTag:exit"(node) {
+        indentLevel.dedent(node);
+      },
       OpenStyleTagStart: checkIndent,
       OpenStyleTagEnd: checkIndent,
       OpenTagStart: checkIndent,
       OpenTagEnd: checkIndent,
       CloseTag: checkIndent,
-      /**
-       * @param {TagNode} node
-       */
       "Tag:exit"(node) {
         if (IGNORING_NODES.includes(node.name)) {
           parentIgnoringChildCount--;
         }
-        unindent();
+        indentLevel.dedent(node);
       },
 
       // Attribute
-      Attribute: indent,
+      Attribute(node) {
+        indentLevel.indent(node);
+      },
       AttributeKey: checkIndent,
       AttributeValue: checkIndent,
-      "Attribute:exit": unindent,
+      "Attribute:exit"(node) {
+        indentLevel.dedent(node);
+      },
 
       // Text
       Text(node) {
-        indent();
+        indentLevel.indent(node);
         const lineNodes = splitToLineNodes(node);
         lineNodes.forEach((lineNode) => {
           if (lineNode.skipIndentCheck) {
@@ -327,13 +343,15 @@ module.exports = {
           }
         });
       },
-      "Text:exit": unindent,
-
-      // Comment
-      Comment: indent,
+      "Text:exit"(node) {
+        indentLevel.dedent(node);
+      },
+      Comment(node) {
+        indentLevel.indent(node);
+      },
       CommentOpen: checkIndent,
       CommentContent(node) {
-        indent();
+        indentLevel.indent(node);
         const lineNodes = splitToLineNodes(node);
         lineNodes.forEach((lineNode) => {
           if (lineNode.skipIndentCheck) {
@@ -345,32 +363,36 @@ module.exports = {
         });
       },
       CommentClose: checkIndent,
-      "Comment:exit": unindent,
-      "CommentContent:exit": unindent,
+      "Comment:exit"(node) {
+        indentLevel.dedent(node);
+      },
+      "CommentContent:exit"(node) {
+        indentLevel.dedent(node);
+      },
     };
 
     return {
       ...visitor,
       TaggedTemplateExpression(node) {
         if (shouldCheckTaggedTemplateExpression(node, context)) {
-          baseIndentLevel = getBaseIndentLevel(node.quasi) + 1;
+          indentLevel.setBase(getBaseIndentLevel(node.quasi) + 1);
           parse(node.quasi, getSourceCode(context), visitor);
         }
       },
       "TaggedTemplateExpression:exit"(node) {
         if (shouldCheckTaggedTemplateExpression(node, context)) {
-          baseIndentLevel = 0;
+          indentLevel.setBase(0);
         }
       },
       TemplateLiteral(node) {
         if (shouldCheckTemplateLiteral(node, context)) {
-          baseIndentLevel = getBaseIndentLevel(node) + 1;
+          indentLevel.setBase(getBaseIndentLevel(node) + 1);
           parse(node, getSourceCode(context), visitor);
         }
       },
       "TemplateLiteral:exit"(node) {
         if (shouldCheckTemplateLiteral(node, context)) {
-          baseIndentLevel = 0;
+          indentLevel.setBase(0);
         }
       },
     };

package/lib/rules/indent/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.30.0-alpha.0",
+  "version": "0.31.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.29.0"
+    "@html-eslint/template-parser": "^0.31.0"
   },
   "devDependencies": {
-    "@html-eslint/parser": "^0.29.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": "bb592a93f1095534de5e0ac0c4f854cc1a49bcab"
+  "gitHead": "0e9ece917af191d223ccec4b17d9096f02a96508"
 }

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