@html-eslint/eslint-plugin 0.26.0 → 0.28.0-alpha.0

package/lib/configs/recommended.js

@@ -7,7 +7,12 @@ module.exports = {
     "@html-eslint/no-multiple-h1": "error",
     "@html-eslint/no-extra-spacing-attrs": "error",
     "@html-eslint/attrs-newline": "error",
-    "@html-eslint/element-newline": "error",
+    "@html-eslint/element-newline": [
+      "error",
+      {
+        inline: [`$inline`],
+      },
+    ],
     "@html-eslint/no-duplicate-id": "error",
     "@html-eslint/indent": "error",
     "@html-eslint/require-li-container": "error",

package/lib/rules/element-newline.js

@@ -3,13 +3,66 @@
  * @typedef { import("../types").ProgramNode } ProgramNode
  * @typedef { import("../types").TagNode } TagNode
  * @typedef { import("../types").BaseNode } BaseNode
+ * @typedef { import("../types").CommentNode } CommentNode
+ * @typedef { import("../types").DoctypeNode } DoctypeNode
+ * @typedef { import("../types").ScriptTagNode } ScriptTagNode
+ * @typedef { import("../types").StyleTagNode } StyleTagNode
+ * @typedef { import("../types").TextNode } TextNode
+ * @typedef { CommentNode | DoctypeNode | ScriptTagNode | StyleTagNode | TagNode | TextNode } NewlineNode
+ * @typedef {{
+ *   childFirst: NewlineNode | null;
+ *   childLast: NewlineNode | null;
+ *   shouldBeNewline: boolean;
+ * }} NodeMeta
  */
 
 const { RULE_CATEGORY } = require("../constants");
 
 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",
+};
+
+/**
+ * @type {Object.<string, Array<string>>}
+ */
+const PRESETS = {
+  // From https://developer.mozilla.org/en-US/docs/Web/HTML/Element#inline_text_semantics
+  $inline: `
+a
+abbr
+b
+bdi
+bdo
+br
+cite
+code
+data
+dfn
+em
+i
+kbd
+mark
+q
+rp
+rt
+ruby
+s
+samp
+small
+span
+strong
+sub
+sup
+time
+u
+var
+wbr
+  `
+    .trim()
+    .split(`\n`),
 };
 
 /**
@@ -30,6 +83,13 @@ module.exports = {
       {
         type: "object",
         properties: {
+          inline: {
+            type: "array",
+            items: {
+              type: "string",
+            },
+          },
+
           skip: {
             type: "array",
             items: {
@@ -41,111 +101,214 @@ module.exports = {
     ],
     messages: {
       [MESSAGE_IDS.EXPECT_NEW_LINE_AFTER]:
-        "There should be a linebreak after {{tag}}.",
+        "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}}.",
+        "There should be a linebreak before {{tag}} element.",
+      [MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE_CLOSE]:
+        "There should be a linebreak before {{tag}} close.",
     },
   },
 
   create(context) {
-    const option = context.options[0] || { skip: [] };
-    const skipTags = option.skip;
-    let skipTagCount = 0;
+    const option = context.options[0] || {};
+    const skipTags = option.skip || [];
+    const inlineTags = optionsOrPresets(option.inline || []);
+
     /**
-     * @param {import("../types").ChildType<TagNode | ProgramNode>[]} siblings
+     * @param {Array<NewlineNode>} siblings
+     * @returns {NodeMeta} meta
      */
     function checkSiblings(siblings) {
-      siblings
-        .filter((node) => node.type !== "Text")
-        .forEach((current, index, arr) => {
-          const after = arr[index + 1];
-          if (after) {
-            if (isOnTheSameLine(current, after)) {
+      /**
+       * @type {NodeMeta}
+       */
+      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];
+
+        if (isEmptyText(node) === false) {
+          nodesWithContent.push(node);
+        }
+      }
+
+      for (
+        let length = nodesWithContent.length, index = 0;
+        index < length;
+        index += 1
+      ) {
+        const node = nodesWithContent[index];
+        const nodeNext = nodesWithContent[index + 1];
+
+        if (meta.childFirst === null) {
+          meta.childFirst = node;
+        }
+
+        meta.childLast = node;
+
+        const nodeShouldBeNewline = shouldBeNewline(node);
+
+        if (node.type === `Tag` && skipTags.includes(node.name) === false) {
+          const nodeMeta = checkSiblings(node.children);
+          const nodeChildShouldBeNewline = nodeMeta.shouldBeNewline;
+
+          if (nodeShouldBeNewline || nodeChildShouldBeNewline) {
+            meta.shouldBeNewline = true;
+          }
+
+          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`);
+                  },
+                });
+              }
+            }
+
+            if (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`);
+                  },
+                });
+              }
+            }
+          }
+        }
+
+        if (nodeNext && node.loc.end.line === nodeNext.loc.start.line) {
+          if (nodeShouldBeNewline) {
+            if (isNotNewlineStart(nodeNext)) {
               context.report({
-                node: current,
+                node: nodeNext,
                 messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
-                // @ts-ignore
-                data: { tag: `<${current.name}>` },
+                data: { tag: label(node) },
                 fix(fixer) {
-                  return fixer.insertTextAfter(current, "\n");
+                  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`);
+                },
+              });
+            }
+          }
+        }
+      }
+
+      return meta;
+    }
+
+    /**
+     * @param {NewlineNode} node
+     */
+    function isEmptyText(node) {
+      return node.type === `Text` && node.value.trim().length === 0;
+    }
+
+    /**
+     * @param {NewlineNode} node
+     */
+    function isNotNewlineEnd(node) {
+      return node.type !== `Text` || /\n\s*$/.test(node.value) === false;
+    }
+
+    /**
+     * @param {NewlineNode} node
+     */
+    function isNotNewlineStart(node) {
+      return node.type !== `Text` || /^\n/.test(node.value) === false;
+    }
+
+    /**
+     * @param {NewlineNode} node
+     * @param {{ isClose?: boolean }} options
+     */
+    function label(node, options = {}) {
+      const isClose = options.isClose || false;
+
+      switch (node.type) {
+        case `Tag`:
+          if (isClose) {
+            return `</${node.name}>`;
           }
-        });
+          return `<${node.name}>`;
+        default:
+          return `<${node.type}>`;
+      }
     }
 
     /**
-     * @param {TagNode} node
-     * @param {import("../types").ChildType<TagNode>[]} children
+     * @param {Array<string>} options
      */
-    function checkChild(node, children) {
-      const targetChildren = children.filter((n) => n.type !== "Text");
-      const first = targetChildren[0];
-      const last = targetChildren[targetChildren.length - 1];
-      if (first) {
-        if (isOnTheSameLine(node.openEnd, first)) {
-          context.report({
-            node: node.openEnd,
-            messageId: MESSAGE_IDS.EXPECT_NEW_LINE_AFTER,
-            data: { tag: `<${node.name}>` },
-            fix(fixer) {
-              return fixer.insertTextAfter(node.openEnd, "\n");
-            },
-          });
+    function optionsOrPresets(options) {
+      const result = [];
+      for (const option of options) {
+        if (option in PRESETS) {
+          const preset = PRESETS[option];
+          result.push(...preset);
+        } else {
+          result.push(option);
         }
       }
+      return result;
+    }
 
-      if (last) {
-        if (node.close && isOnTheSameLine(node.close, last)) {
-          context.report({
-            node: node.close,
-            messageId: MESSAGE_IDS.EXPECT_NEW_LINE_BEFORE,
-            data: { tag: `</${node.name}>` },
-            fix(fixer) {
-              return fixer.insertTextBefore(node.close, "\n");
-            },
-          });
-        }
+    /**
+     * @param {NewlineNode} node
+     */
+    function shouldBeNewline(node) {
+      switch (node.type) {
+        case `Comment`:
+          return /[\n\r]+/.test(node.value.value.trim());
+        case `Tag`:
+          return inlineTags.includes(node.name.toLowerCase()) === false;
+        case `Text`:
+          return /[\n\r]+/.test(node.value.trim());
+        default:
+          return true;
       }
     }
+
     return {
       Program(node) {
+        // @ts-ignore
         checkSiblings(node.body);
       },
-      Tag(node) {
-        if (skipTagCount > 0) {
-          return;
-        }
-        if (skipTags.includes(node.name)) {
-          skipTagCount++;
-          return;
-        }
-        checkSiblings(node.children);
-        checkChild(node, node.children);
-      },
-      /**
-       * @param {TagNode} node
-       * @returns
-       */
-      "Tag:exit"(node) {
-        if (skipTags.includes(node.name)) {
-          skipTagCount--;
-          return;
-        }
-      },
     };
   },
 };
-
-/**
- * @param {BaseNode} nodeBefore
- * @param {BaseNode} nodeAfter
- * @returns
- */
-function isOnTheSameLine(nodeBefore, nodeAfter) {
-  if (nodeBefore && nodeAfter) {
-    return nodeBefore.loc.end.line === nodeAfter.loc.start.line;
-  }
-  return false;
-}

package/lib/rules/index.js

@@ -6,6 +6,7 @@ const noDuplicateId = require("./no-duplicate-id");
 const noInlineStyles = require("./no-inline-styles");
 const noMultipleH1 = require("./no-multiple-h1");
 const noExtraSpacingAttrs = require("./no-extra-spacing-attrs");
+const noExtraSpacingText = require("./no-extra-spacing-text");
 const attrsNewline = require("./attrs-newline");
 const elementNewLine = require("./element-newline");
 const noSkipHeadingLevels = require("./no-skip-heading-levels");
@@ -46,6 +47,7 @@ module.exports = {
   "no-inline-styles": noInlineStyles,
   "no-multiple-h1": noMultipleH1,
   "no-extra-spacing-attrs": noExtraSpacingAttrs,
+  "no-extra-spacing-text": noExtraSpacingText,
   "attrs-newline": attrsNewline,
   "element-newline": elementNewLine,
   "no-skip-heading-levels": noSkipHeadingLevels,

package/lib/rules/no-extra-spacing-attrs.js

@@ -21,6 +21,7 @@ const MESSAGE_IDS = {
   EXTRA_AFTER: "unexpectedAfter",
   EXTRA_BEFORE: "unexpectedBefore",
   EXTRA_BEFORE_CLOSE: "unexpectedBeforeClose",
+  EXTRA_IN_ASSIGNMENT: "unexpectedInAssignment",
   MISSING_BEFORE: "missingBefore",
   MISSING_BEFORE_SELF_CLOSE: "missingBeforeSelfClose",
   EXTRA_BEFORE_SELF_CLOSE: "unexpectedBeforeSelfClose",
@@ -47,6 +48,9 @@ module.exports = {
       {
         type: "object",
         properties: {
+          disallowInAssignment: {
+            type: "boolean",
+          },
           disallowMissing: {
             type: "boolean",
           },
@@ -64,6 +68,8 @@ module.exports = {
       [MESSAGE_IDS.EXTRA_AFTER]: "Unexpected space after attribute",
       [MESSAGE_IDS.EXTRA_BEFORE]: "Unexpected space before attribute",
       [MESSAGE_IDS.EXTRA_BEFORE_CLOSE]: "Unexpected space before closing",
+      [MESSAGE_IDS.EXTRA_IN_ASSIGNMENT]:
+        "Unexpected space in attribute assignment",
       [MESSAGE_IDS.MISSING_BEFORE_SELF_CLOSE]:
         "Missing space before self closing",
       [MESSAGE_IDS.EXTRA_BEFORE_SELF_CLOSE]:
@@ -82,6 +88,8 @@ module.exports = {
       .enforceBeforeSelfClose;
     const disallowMissing = !!(context.options[0] || {}).disallowMissing;
     const disallowTabs = !!(context.options[0] || {}).disallowTabs;
+    const disallowInAssignment = !!(context.options[0] || [])
+      .disallowInAssignment;
 
     const sourceCode = context.getSourceCode().text;
 
@@ -104,7 +112,10 @@ module.exports = {
             loc: getLocBetween(current, after),
             messageId: MESSAGE_IDS.EXTRA_BETWEEN,
             fix(fixer) {
-              return fixer.removeRange([current.range[1] + 1, after.range[0]]);
+              return fixer.replaceTextRange(
+                [current.range[1], after.range[0]],
+                ` `
+              );
             },
           });
         } else if (disallowMissing && spacesBetween < 1) {
@@ -122,7 +133,7 @@ module.exports = {
               messageId: MESSAGE_IDS.EXTRA_TAB_BETWEEN,
               fix(fixer) {
                 return fixer.replaceTextRange(
-                  [current.range[1], current.range[1] + 1],
+                  [current.range[1], after.range[0]],
                   ` `
                 );
               },
@@ -184,6 +195,25 @@ module.exports = {
 
         if (node.attributes.length) {
           checkExtraSpaceBefore(node.openStart, node.attributes[0]);
+
+          for (const attr of node.attributes) {
+            if (attr.startWrapper && attr.value) {
+              if (
+                disallowInAssignment &&
+                attr.startWrapper.loc.start.column - attr.key.loc.end.column > 1
+              ) {
+                const start = attr.key.range[1];
+                const end = attr.startWrapper.range[0];
+                context.report({
+                  node: attr,
+                  messageId: MESSAGE_IDS.EXTRA_IN_ASSIGNMENT,
+                  fix(fixer) {
+                    return fixer.replaceTextRange([start, end], `=`);
+                  },
+                });
+              }
+            }
+          }
         }
 
         if (node.openEnd) {

package/lib/rules/no-extra-spacing-text.js

@@ -0,0 +1,117 @@
+/**
+ * @typedef { import("../types").RuleModule } RuleModule
+ * @typedef { import("../types").ProgramNode } ProgramNode
+ * @typedef { import("es-html-parser").CommentContentNode } CommentContentNode
+ * @typedef { import("../types").ContentNode } ContentNode
+ * @typedef { import("../types").TextNode } TextNode
+ */
+
+const { RULE_CATEGORY } = require("../constants");
+
+const MESSAGE_IDS = {
+  UNEXPECTED: "unexpected",
+};
+
+/**
+ * @type {RuleModule}
+ */
+module.exports = {
+  meta: {
+    type: "code",
+
+    docs: {
+      description: "Disallow unnecessary consecutive spaces",
+      category: RULE_CATEGORY.BEST_PRACTICE,
+      recommended: false,
+    },
+
+    fixable: true,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          skip: {
+            type: "array",
+            items: {
+              type: "string",
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      [MESSAGE_IDS.UNEXPECTED]:
+        "Tabs and/or multiple consecutive spaces not allowed here",
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const skipTags = options.skip || [];
+    const sourceCode = context.getSourceCode();
+
+    /**
+     * @param {Array<ContentNode>} siblings
+     */
+    function checkSiblings(siblings) {
+      for (
+        let length = siblings.length, index = 0;
+        index < length;
+        index += 1
+      ) {
+        const node = siblings[index];
+
+        if (node.type === `Tag` && skipTags.includes(node.name) === false) {
+          checkSiblings(node.children);
+        } else if (node.type === `Text`) {
+          stripConsecutiveSpaces(node);
+        } else if (node.type === `Comment`) {
+          stripConsecutiveSpaces(node.value);
+        }
+      }
+    }
+
+    return {
+      Program(node) {
+        // @ts-ignore
+        checkSiblings(node.body);
+      },
+    };
+
+    /**
+     * @param {TextNode | CommentContentNode} node
+     */
+    function stripConsecutiveSpaces(node) {
+      const text = node.value;
+      const matcher = /(^|[^\n \t])([ \t]+\n|\t[\t ]*|[ \t]{2,})/g;
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const offender = matcher.exec(text);
+        if (offender === null) {
+          break;
+        }
+
+        const space = offender[2];
+        const indexStart = node.range[0] + matcher.lastIndex - space.length;
+        const indexEnd = indexStart + space.length;
+
+        context.report({
+          node: node,
+          loc: {
+            start: sourceCode.getLocFromIndex(indexStart),
+            end: sourceCode.getLocFromIndex(indexEnd),
+          },
+          messageId: MESSAGE_IDS.UNEXPECTED,
+          fix(fixer) {
+            return fixer.replaceTextRange(
+              [indexStart, indexEnd],
+              space.endsWith(`\n`) ? `\n` : ` `
+            );
+          },
+        });
+      }
+    }
+  },
+};

package/lib/rules/no-inline-styles.js

@@ -1,10 +1,16 @@
 /**
  * @typedef { import("../types").RuleModule } RuleModule
+ * @typedef { import("../types").RuleListener } RuleListener
  */
 
 const { RULE_CATEGORY } = require("../constants");
 const { findAttr } = require("./utils/node");
-
+const { parse } = require("@html-eslint/template-parser");
+const {
+  shouldCheckTaggedTemplateExpression,
+  shouldCheckTemplateLiteral,
+} = require("./utils/settings");
+const { getSourceCode } = require("./utils/source-code");
 const MESSAGE_IDS = {
   INLINE_STYLE: "unexpectedInlineStyle",
 };
@@ -30,7 +36,10 @@ module.exports = {
   },
 
   create(context) {
-    return {
+    /**
+     * @type {RuleListener}
+     */
+    const visitors = {
       Tag(node) {
         const styleAttr = findAttr(node, "style");
         if (styleAttr) {
@@ -41,5 +50,19 @@ module.exports = {
         }
       },
     };
+
+    return {
+      ...visitors,
+      TaggedTemplateExpression(node) {
+        if (shouldCheckTaggedTemplateExpression(node, context)) {
+          parse(node.quasi, getSourceCode(context), visitors);
+        }
+      },
+      TemplateLiteral(node) {
+        if (shouldCheckTemplateLiteral(node, context)) {
+          parse(node, getSourceCode(context), visitors);
+        }
+      },
+    };
   },
 };

package/lib/rules/utils/settings.js

@@ -0,0 +1,88 @@
+/**
+ * @typedef {import("../../types").MaybeHTMLSettings} MaybeHTMLSettings
+ * @typedef {import("../../types").HTMLSettings} HTMLSettings
+ * @typedef {import("../../types").Context} Context
+ * @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression
+ * @typedef {import("estree").TemplateLiteral} TemplateLiteral
+ */
+
+const { getSourceCode } = require("../utils/source-code");
+
+const DEFAULT_SETTINGS = {
+  templateLiterals: {
+    tags: ["^html$"],
+    comments: ["^\\s*html\\s*$"],
+  },
+};
+
+/**
+ * @type {HTMLSettings | null}
+ */
+let cachedSettings = null;
+
+/**
+ * @param {{ html?: MaybeHTMLSettings }} settings
+ * @returns {HTMLSettings}
+ */
+function getSettings(settings) {
+  const tags =
+    (settings &&
+      settings.html &&
+      settings.html.templateLiterals &&
+      settings.html.templateLiterals.tags) ||
+    DEFAULT_SETTINGS.templateLiterals.tags;
+
+  const comments =
+    (settings &&
+      settings.html &&
+      settings.html.templateLiterals &&
+      settings.html.templateLiterals.comments) ||
+    DEFAULT_SETTINGS.templateLiterals.comments;
+
+  if (cachedSettings) {
+    return cachedSettings;
+  }
+  cachedSettings = {
+    templateLiterals: {
+      tags: tags.map((tag) => new RegExp(tag, "u")),
+      comments: comments.map((comment) => new RegExp(comment, "u")),
+    },
+  };
+  return cachedSettings;
+}
+
+/**
+ * @param {TaggedTemplateExpression} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function shouldCheckTaggedTemplateExpression(node, context) {
+  const { templateLiterals } = getSettings(context.settings);
+  const tags = templateLiterals.tags;
+  const tagNode = node.tag;
+  return !!(
+    tagNode.type === "Identifier" && tags.some((tag) => tag.test(tagNode.name))
+  );
+}
+
+/**
+ *
+ * @param {TemplateLiteral} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function shouldCheckTemplateLiteral(node, context) {
+  const sourceCode = getSourceCode(context);
+  const { templateLiterals } = getSettings(context.settings);
+  const comments = sourceCode.getCommentsBefore(node);
+  const last = comments[comments.length - 1];
+  return !!(
+    last &&
+    templateLiterals.comments.some((comment) => comment.test(last.value))
+  );
+}
+
+module.exports = {
+  shouldCheckTemplateLiteral,
+  shouldCheckTaggedTemplateExpression,
+};

package/lib/rules/utils/source-code.js

@@ -0,0 +1,14 @@
+/**
+ * @typedef {import("../../types").Context} Context
+ */
+
+/**
+ * @param {Context} context
+ */
+function getSourceCode(context) {
+  return context.sourceCode || context.getSourceCode();
+}
+
+module.exports = {
+  getSourceCode,
+};

package/lib/types.d.ts

@@ -1,4 +1,4 @@
-import ESTree from "estree";
+import ESTree, { TaggedTemplateExpression, TemplateLiteral } from "estree";
 import ESLint from "eslint";
 import * as ESHtml from "es-html-parser";
 
@@ -200,12 +200,14 @@ interface RuleListener {
   CommentClose?: (node: CommentCloseNode) => void;
   CommentContent?: (node: CommentContentNode) => void;
   Doctype?: (node: DoctypeNode) => void;
-  DoctypeOpen: (node: DoctypeOpenNode) => void;
+  DoctypeOpen?: (node: DoctypeOpenNode) => void;
   DoctypeClose?: (node: DoctypeCloseNode) => void;
   DoctypeAttribute?: (node: DoctypeAttributeNode) => void;
   DoctypeAttributeValue?: (node: DoctypeAttributeValueNode) => void;
   DoctypeAttributeWrapperStart?: (node: DoctypeAttributeWrapperStart) => void;
   DoctypeAttributeWrapperEnd?: (node: DoctypeAttributeWrapperEnd) => void;
+  TaggedTemplateExpression?: (node: TaggedTemplateExpression) => void;
+  TemplateLiteral?: (node: TemplateLiteral) => void;
 }
 
 export interface RuleModule extends ESLint.Rule.RuleModule {
@@ -258,7 +260,7 @@ type ReportDescriptorLocation = {
   column?: number;
 };
 
-interface Context extends Omit<ESLint.Rule.RuleContext, "report"> {
+export interface Context extends Omit<ESLint.Rule.RuleContext, "report"> {
   report(descriptor: ReportDescriptor): void;
 }
 
@@ -267,3 +269,25 @@ export type ChildType<T extends BaseNode> = T extends ProgramNode
   : T extends TagNode
   ? T["children"][number]
   : never;
+
+export type ContentNode =
+  | CommentNode
+  | DoctypeNode
+  | ScriptTagNode
+  | StyleTagNode
+  | TagNode
+  | TextNode;
+
+export type MaybeHTMLSettings = {
+  templateLiterals?: {
+    tags?: string[];
+    comments?: string[];
+  };
+};
+
+export type HTMLSettings = {
+  templateLiterals: {
+    tags: RegExp[];
+    comments: RegExp[];
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.26.0",
+  "version": "0.28.0-alpha.0",
   "description": "ESLint plugin for html",
   "author": "yeonjuan",
   "homepage": "https://github.com/yeonjuan/html-eslint#readme",
@@ -45,11 +45,13 @@
     "accessibility"
   ],
   "devDependencies": {
-    "@html-eslint/parser": "^0.26.0",
-    "@types/eslint": "^8.56.2",
+    "@html-eslint/parser": "^0.28.0-alpha.0",
+    "@html-eslint/template-parser": "^0.28.0-alpha.0",
+    "@types/eslint": "^9.6.1",
     "@types/estree": "^0.0.47",
     "es-html-parser": "^0.0.8",
+    "espree": "^10.3.0",
     "typescript": "^4.4.4"
   },
-  "gitHead": "34d55c3b5be5a29cc416063b4b4375cb89b3a519"
+  "gitHead": "4c4e3388a4d8541ade0201fb06690e46098ab9bf"
 }

package/types/configs/recommended.d.ts

@@ -6,7 +6,9 @@ export const rules: {
     "@html-eslint/no-multiple-h1": string;
     "@html-eslint/no-extra-spacing-attrs": string;
     "@html-eslint/attrs-newline": string;
-    "@html-eslint/element-newline": string;
+    "@html-eslint/element-newline": (string | {
+        inline: string[];
+    })[];
     "@html-eslint/no-duplicate-id": string;
     "@html-eslint/indent": string;
     "@html-eslint/require-li-container": string;

package/types/rules/element-newline.d.ts

@@ -4,4 +4,15 @@ export type RuleModule = import("../types").RuleModule;
 export type ProgramNode = import("../types").ProgramNode;
 export type TagNode = import("../types").TagNode;
 export type BaseNode = import("../types").BaseNode;
+export type CommentNode = import("../types").CommentNode;
+export type DoctypeNode = import("../types").DoctypeNode;
+export type ScriptTagNode = import("../types").ScriptTagNode;
+export type StyleTagNode = import("../types").StyleTagNode;
+export type TextNode = import("../types").TextNode;
+export type NewlineNode = CommentNode | DoctypeNode | ScriptTagNode | StyleTagNode | TagNode | TextNode;
+export type NodeMeta = {
+    childFirst: NewlineNode | null;
+    childLast: NewlineNode | null;
+    shouldBeNewline: boolean;
+};
 //# sourceMappingURL=element-newline.d.ts.map

package/types/rules/element-newline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"element-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/element-newline.js"],"names":[],"mappings":"wBAeU,UAAU;;yBAdN,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,UAAU,EAAE,WAAW;sBAC9B,OAAO,UAAU,EAAE,OAAO;uBAC1B,OAAO,UAAU,EAAE,QAAQ"}
+{"version":3,"file":"element-newline.d.ts","sourceRoot":"","sources":["../../lib/rules/element-newline.js"],"names":[],"mappings":"wBAoEU,UAAU;;yBAnEN,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,UAAU,EAAE,WAAW;sBAC9B,OAAO,UAAU,EAAE,OAAO;uBAC1B,OAAO,UAAU,EAAE,QAAQ;0BAC3B,OAAO,UAAU,EAAE,WAAW;0BAC9B,OAAO,UAAU,EAAE,WAAW;4BAC9B,OAAO,UAAU,EAAE,aAAa;2BAChC,OAAO,UAAU,EAAE,YAAY;uBAC/B,OAAO,UAAU,EAAE,QAAQ;0BAC3B,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ;uBAC9E;IACZ,UAAc,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,SAAa,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,eAAmB,EAAE,OAAO,CAAC;CAC1B"}

package/types/rules/index.d.ts

@@ -7,6 +7,7 @@ declare const _exports: {
     "no-inline-styles": import("../types").RuleModule;
     "no-multiple-h1": import("../types").RuleModule;
     "no-extra-spacing-attrs": import("../types").RuleModule;
+    "no-extra-spacing-text": import("../types").RuleModule;
     "attrs-newline": import("../types").RuleModule;
     "element-newline": import("../types").RuleModule;
     "no-skip-heading-levels": import("../types").RuleModule;

package/types/rules/no-extra-spacing-attrs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-extra-spacing-attrs.d.ts","sourceRoot":"","sources":["../../lib/rules/no-extra-spacing-attrs.js"],"names":[],"mappings":"wBAgCU,UAAU;;yBA/BN,OAAO,UAAU,EAAE,UAAU;4BAC7B,OAAO,UAAU,EAAE,aAAa;6BAChC,OAAO,UAAU,EAAE,cAAc;mCACjC,OAAO,UAAU,EAAE,oBAAoB;kCACvC,OAAO,UAAU,EAAE,mBAAmB;qCACtC,OAAO,UAAU,EAAE,sBAAsB;+BACzC,OAAO,UAAU,EAAE,gBAAgB;oCACnC,OAAO,UAAU,EAAE,qBAAqB;sBACxC,OAAO,UAAU,EAAE,OAAO;2BAC1B,OAAO,UAAU,EAAE,YAAY;4BAC/B,OAAO,UAAU,EAAE,aAAa;sBAChC,OAAO,UAAU,EAAE,OAAO"}
+{"version":3,"file":"no-extra-spacing-attrs.d.ts","sourceRoot":"","sources":["../../lib/rules/no-extra-spacing-attrs.js"],"names":[],"mappings":"wBAiCU,UAAU;;yBAhCN,OAAO,UAAU,EAAE,UAAU;4BAC7B,OAAO,UAAU,EAAE,aAAa;6BAChC,OAAO,UAAU,EAAE,cAAc;mCACjC,OAAO,UAAU,EAAE,oBAAoB;kCACvC,OAAO,UAAU,EAAE,mBAAmB;qCACtC,OAAO,UAAU,EAAE,sBAAsB;+BACzC,OAAO,UAAU,EAAE,gBAAgB;oCACnC,OAAO,UAAU,EAAE,qBAAqB;sBACxC,OAAO,UAAU,EAAE,OAAO;2BAC1B,OAAO,UAAU,EAAE,YAAY;4BAC/B,OAAO,UAAU,EAAE,aAAa;sBAChC,OAAO,UAAU,EAAE,OAAO"}

package/types/rules/no-extra-spacing-text.d.ts

@@ -0,0 +1,8 @@
+declare const _exports: RuleModule;
+export = _exports;
+export type RuleModule = import("../types").RuleModule;
+export type ProgramNode = import("../types").ProgramNode;
+export type CommentContentNode = import("es-html-parser").CommentContentNode;
+export type ContentNode = import("../types").ContentNode;
+export type TextNode = import("../types").TextNode;
+//# sourceMappingURL=no-extra-spacing-text.d.ts.map

package/types/rules/no-extra-spacing-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-extra-spacing-text.d.ts","sourceRoot":"","sources":["../../lib/rules/no-extra-spacing-text.js"],"names":[],"mappings":"wBAeU,UAAU;;yBAdN,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,UAAU,EAAE,WAAW;iCAC9B,OAAO,gBAAgB,EAAE,kBAAkB;0BAC3C,OAAO,UAAU,EAAE,WAAW;uBAC9B,OAAO,UAAU,EAAE,QAAQ"}

package/types/rules/no-inline-styles.d.ts

@@ -1,4 +1,5 @@
 declare const _exports: RuleModule;
 export = _exports;
 export type RuleModule = import("../types").RuleModule;
+export type RuleListener = import("../types").RuleListener;
 //# sourceMappingURL=no-inline-styles.d.ts.map

package/types/rules/no-inline-styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-inline-styles.d.ts","sourceRoot":"","sources":["../../lib/rules/no-inline-styles.js"],"names":[],"mappings":"wBAYU,UAAU;;yBAXN,OAAO,UAAU,EAAE,UAAU"}
+{"version":3,"file":"no-inline-styles.d.ts","sourceRoot":"","sources":["../../lib/rules/no-inline-styles.js"],"names":[],"mappings":"wBAkBU,UAAU;;yBAjBN,OAAO,UAAU,EAAE,UAAU;2BAC7B,OAAO,UAAU,EAAE,YAAY"}

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

@@ -13,7 +13,7 @@ export type Location = import("../../types").Location;
  * @param {string} key
  * @returns {AttributeNode | undefined}
  */
-declare function findAttr(node: import("../../types").TagNode | import("../../types").ScriptTagNode | import("../../types").StyleTagNode, key: string): import("../../types").AttributeNode | undefined;
+declare function findAttr(node: import("../../types").ScriptTagNode | import("../../types").TagNode | import("../../types").StyleTagNode, key: string): import("../../types").AttributeNode | undefined;
 /**
  * Checks whether a node's all tokens are on the same line or not.
  * @param {AnyNode} node A node to check

package/types/rules/utils/settings.d.ts

@@ -0,0 +1,19 @@
+export type MaybeHTMLSettings = import("../../types").MaybeHTMLSettings;
+export type HTMLSettings = import("../../types").HTMLSettings;
+export type Context = import("../../types").Context;
+export type TaggedTemplateExpression = import("estree").TaggedTemplateExpression;
+export type TemplateLiteral = import("estree").TemplateLiteral;
+/**
+ *
+ * @param {TemplateLiteral} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+export function shouldCheckTemplateLiteral(node: TemplateLiteral, context: Context): boolean;
+/**
+ * @param {TaggedTemplateExpression} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+export function shouldCheckTaggedTemplateExpression(node: TaggedTemplateExpression, context: Context): boolean;
+//# sourceMappingURL=settings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../lib/rules/utils/settings.js"],"names":[],"mappings":"gCACa,OAAO,aAAa,EAAE,iBAAiB;2BACvC,OAAO,aAAa,EAAE,YAAY;sBAClC,OAAO,aAAa,EAAE,OAAO;uCAC7B,OAAO,QAAQ,EAAE,wBAAwB;8BACzC,OAAO,QAAQ,EAAE,eAAe;AA8D7C;;;;;GAKG;AACH,iDAJW,eAAe,WACf,OAAO,GACL,OAAO,CAWnB;AA7BD;;;;GAIG;AACH,0DAJW,wBAAwB,WACxB,OAAO,GACL,OAAO,CASnB"}

package/types/rules/utils/source-code.d.ts

@@ -0,0 +1,9 @@
+export type Context = import("../../types").Context;
+/**
+ * @typedef {import("../../types").Context} Context
+ */
+/**
+ * @param {Context} context
+ */
+export function getSourceCode(context: Context): import("eslint").SourceCode;
+//# sourceMappingURL=source-code.d.ts.map

package/types/rules/utils/source-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-code.d.ts","sourceRoot":"","sources":["../../../lib/rules/utils/source-code.js"],"names":[],"mappings":"sBACa,OAAO,aAAa,EAAE,OAAO;AAD1C;;GAEG;AAEH;;GAEG;AACH,uCAFW,OAAO,+BAIjB"}