@askviraj/linter 1.1.4 → 1.1.6

package/node_modules/@html-eslint/parser/lib/branch-annotation.js

@@ -0,0 +1,282 @@
+/** @import {TemplateSyntax} from "@html-eslint/template-syntax-parser" */
+
+/**
+ * Branch annotation for @html-eslint/parser.
+ *
+ * @typedef {{
+ *   groupId: number;
+ *   branchIndex: number;
+ *   start: number;
+ *   end: number;
+ * }} BranchSegment
+ * @html-eslint/template-syntax-parser already records every template token as
+ * an opaque {open, close} range pair.  This module classifies those tokens
+ * (using per-engine patterns stored in the SyntaxConfigItem.branch property)
+ * and emits a flat list of BranchSegment objects.
+ *
+ * A BranchSegment represents one branch body of one {% if %} block:
+ *   groupId      — same for all branches of the same if-block
+ *   branchIndex  — 0 for the if-body, 1 for first elseif/else, etc.
+ *   start / end  — source character range of the branch content (exclusive of
+ *                  the template tokens themselves)
+ *
+ * Rules can use these segments to decide whether two "duplicate" nodes are
+ * actually unreachable simultaneously, because every path through the template
+ * can only enter one branch of any given if-block.
+ */
+
+/**
+ * @param {RegExp | string | undefined} pattern
+ * @param {string} content
+ * @returns {boolean}
+ */
+function matches(pattern, content) {
+  if (!pattern) return false;
+  if (pattern instanceof RegExp) return pattern.test(content);
+  return content.indexOf(pattern) !== -1;
+}
+
+/**
+ * Classify every template token that belongs to a branch-aware delimiter.
+ *
+ * @param {TemplateSyntax[]} templateInfos
+ * @param {string} source
+ * @param {{
+ *   open: string;
+ *   close: string;
+ *   branch?: {
+ *     start: RegExp | string;
+ *     continue: RegExp | string;
+ *     end: RegExp | string;
+ *     blockOpen?: RegExp | string;
+ *     blockClose?: RegExp | string;
+ *   };
+ * }[]} syntaxItems
+ * @returns {{
+ *   role: "START" | "CONTINUE" | "END" | "BLOCK_OPEN" | "BLOCK_CLOSE";
+ *   tokenStart: number;
+ *   tokenEnd: number;
+ * }[]}
+ */
+function classifyTemplateTokens(templateInfos, source, syntaxItems) {
+  /** @type {Map<string, (typeof syntaxItems)[number]>} */
+  const itemByOpen = new Map();
+  for (const item of syntaxItems) {
+    if (item.branch) {
+      itemByOpen.set(item.open, item);
+    }
+  }
+  if (itemByOpen.size === 0) return [];
+
+  /**
+   * @type {{
+   *   role: "START" | "CONTINUE" | "END" | "BLOCK_OPEN" | "BLOCK_CLOSE";
+   *   tokenStart: number;
+   *   tokenEnd: number;
+   * }[]}
+   */
+  const classified = [];
+
+  for (const info of templateInfos) {
+    const openDelim = source.slice(info.open[0], info.open[1]);
+    const item = itemByOpen.get(openDelim);
+    if (!item || !item.branch) continue;
+
+    // Content between the opening and closing delimiters, e.g. " if cond ".
+    const content = source.slice(info.open[1], info.close[0]);
+    const b = item.branch;
+
+    /**
+     * @type {"START"
+     *   | "CONTINUE"
+     *   | "END"
+     *   | "BLOCK_OPEN"
+     *   | "BLOCK_CLOSE"
+     *   | null}
+     */
+    let role = null;
+    // Order matters: END before CONTINUE so that patterns like
+    // /^\s*-?\s*(elseif|else)\b/ don't accidentally match "endif" (they won't
+    // with these specific patterns, but being explicit is safer).
+    if (matches(b.start, content)) {
+      role = "START";
+    } else if (matches(b.end, content)) {
+      role = "END";
+    } else if (matches(b.continue, content)) {
+      role = "CONTINUE";
+    } else if (b.blockOpen && matches(b.blockOpen, content)) {
+      role = "BLOCK_OPEN";
+    } else if (b.blockClose && matches(b.blockClose, content)) {
+      role = "BLOCK_CLOSE";
+    }
+
+    if (role) {
+      classified.push({
+        role,
+        tokenStart: info.open[0],
+        tokenEnd: info.close[1],
+      });
+    }
+  }
+
+  // template-syntax-parser emits tokens in source order, but sort defensively.
+  classified.sort((a, b) => a.tokenStart - b.tokenStart);
+  return classified;
+}
+
+/**
+ * Compute branch segments from a list of template token ranges.
+ *
+ * @param {TemplateSyntax[]} templateInfos The TemplateSyntax[] returned by
+ * @param {string} source The source text that templateInfos was parsed from.
+ *   Must be the same string (same character offsets) — i.e. the
+ *   frontmatter-stripped `html` string from getOptions(), NOT the full `code`
+ *   string. The caller is responsible for adding any frontmatter offset to the
+ *   returned segments.
+ * @param {{
+ *   open: string;
+ *   close: string;
+ *   branch?: {
+ *     start: RegExp;
+ *     continue: RegExp;
+ *     end: RegExp;
+ *     blockOpen?: RegExp;
+ *     blockClose?: RegExp;
+ *   };
+ * }[]} syntaxItems
+ *   Normalized SyntaxConfigItem array. Only items that have a .branch property
+ *   are consulted; the rest are ignored.
+ * @returns {BranchSegment[]}
+ * @html-eslint/template-syntax-parser. Each entry covers one complete
+ *   template token: open is the [start,end] of the opening delimiter, close is
+ *   the [start,end] of the closing delimiter. Content lives between open[1] and
+ *   close[0].
+ */
+function computeBranchSegments(templateInfos, source, syntaxItems) {
+  const classified = classifyTemplateTokens(templateInfos, source, syntaxItems);
+  if (classified.length === 0) return [];
+
+  // --- Stack-based pass to build BranchSegments. ---
+  //
+  // Stack entries are one of two shapes:
+  //   { type: 'if',    groupId, branchIndex, segmentStart }
+  //   { type: 'block' }
+  //
+  // The 'block' entries represent non-if blocks (for, macro, etc.) that may
+  // themselves contain an `else` clause.  By tracking them on the same stack
+  // we ensure that an `else` or `elseif` token is only credited to the
+  // nearest enclosing `if`, not to an outer one.
+
+  /** @type {BranchSegment[]} */
+  const segments = [];
+  let groupId = 0;
+  /**
+   * @type {(
+   *   | {
+   *       type: "if";
+   *       groupId: number;
+   *       branchIndex: number;
+   *       segmentStart: number;
+   *     }
+   *   | { type: "block" }
+   * )[]}
+   */
+  const stack = [];
+
+  for (const token of classified) {
+    const top = stack.length > 0 ? stack[stack.length - 1] : null;
+
+    switch (token.role) {
+      case "START":
+        stack.push({
+          type: "if",
+          groupId: groupId++,
+          branchIndex: 0,
+          segmentStart: token.tokenEnd,
+        });
+        break;
+
+      case "BLOCK_OPEN":
+        stack.push({ type: "block" });
+        break;
+
+      case "CONTINUE":
+        // Only process when the immediately enclosing block is an if-block.
+        // A CONTINUE inside {% for %}...{% else %}...{% endfor %} will have
+        // a 'block' entry on top → ignored, so the outer if-block is safe.
+        if (top && top.type === "if") {
+          segments.push({
+            groupId: top.groupId,
+            branchIndex: top.branchIndex,
+            start: top.segmentStart,
+            end: token.tokenStart,
+          });
+          top.branchIndex++;
+          top.segmentStart = token.tokenEnd;
+        }
+        break;
+
+      case "END":
+        if (top && top.type === "if") {
+          stack.pop();
+          segments.push({
+            groupId: top.groupId,
+            branchIndex: top.branchIndex,
+            start: top.segmentStart,
+            end: token.tokenStart,
+          });
+        }
+        break;
+
+      case "BLOCK_CLOSE":
+        if (top && top.type === "block") {
+          stack.pop();
+        }
+        break;
+    }
+  }
+
+  return segments;
+}
+
+/**
+ * Return the [start, end] ranges of every template token that was classified as
+ * a branch-control token (START / CONTINUE / END / BLOCK_OPEN / BLOCK_CLOSE) —
+ * i.e. an `{% if %}`, `{% else %}`, `{% endif %}`, or similar structural token,
+ * as opposed to a plain value-interpolation token like `{{ name }}`.
+ *
+ * Rules use this to distinguish two situations where a template token ends up
+ * glued onto the text of a following attribute key (because there is no
+ * whitespace separating them, e.g. `{%if x%}data-id="1"`):
+ *
+ * 1. The glued token is a branch-control token — the attribute's real name
+ *    ("data-id") is statically known and can be safely compared across branches
+ *    once the glued prefix is stripped.
+ * 2. The glued token is a plain interpolation — the attribute's name is genuinely
+ *    dynamic (e.g. `data-{{name}}`) and can't be safely compared at all, so it
+ *    must continue to be skipped.
+ *
+ * @param {TemplateSyntax[]} templateInfos
+ * @param {string} source
+ * @param {{
+ *   open: string;
+ *   close: string;
+ *   branch?: {
+ *     start: RegExp | string;
+ *     continue: RegExp | string;
+ *     end: RegExp | string;
+ *     blockOpen?: RegExp | string;
+ *     blockClose?: RegExp | string;
+ *   };
+ * }[]} syntaxItems
+ * @returns {[number, number][]}
+ */
+function getControlTokenRanges(templateInfos, source, syntaxItems) {
+  const classified = classifyTemplateTokens(templateInfos, source, syntaxItems);
+  return classified.map((t) => [t.tokenStart, t.tokenEnd]);
+}
+
+module.exports = {
+  computeBranchSegments,
+  getControlTokenRanges,
+};

package/node_modules/@html-eslint/parser/lib/options.js

@@ -6,10 +6,42 @@
 
 const templateSyntaxParser = require("@html-eslint/template-syntax-parser");
 const { parseFrontmatterContent } = require("./frontmatter");
+
+/**
+ * Normalize the templateEngineSyntax option to a plain SyntaxConfigItem[] so
+ * that the branch-annotation pass can inspect the `.branch` property on each
+ * item. The template-syntax-parser performs the same normalization internally;
+ * we replicate it here rather than reaching into its internals.
+ *
+ * @param {ParserOptions["templateEngineSyntax"]} syntax
+ * @returns {{ open: string; close: string; [key: string]: unknown }[]}
+ */
+function normalizeSyntax(syntax) {
+  if (!syntax) return [];
+  if (Array.isArray(syntax)) {
+    // Return a shallow copy to avoid mutating frozen exports from @html-eslint/parser
+    return syntax.map(
+      /** @param {{ open: string; close: string; branch?: unknown }} item */
+      (item) => ({
+        open: item.open,
+        close: item.close,
+        ...(item.branch ? { branch: { ...item.branch } } : {}),
+      })
+    );
+  }
+  // Record<string, string> shorthand form — no branch config possible.
+  return Object.entries(syntax).map(([open, close]) => ({ open, close }));
+}
+
 /**
  * @param {string} code
  * @param {ParserOptions | undefined} parserOptions
- * @returns {{ options: Parameters<ESHtmlParser["parse"]>[1]; html: string }}
+ * @returns {{
+ *   options: Parameters<ESHtmlParser["parse"]>[1];
+ *   html: string;
+ *   syntaxItems: { open: string; close: string; [key: string]: unknown }[];
+ *   frontmatterOffset: number;
+ * }}
  */
 function getOptions(code, parserOptions) {
   let html = code;
@@ -17,15 +49,24 @@ function getOptions(code, parserOptions) {
     return {
       options: undefined,
       html,
+      syntaxItems: [],
+      frontmatterOffset: 0,
     };
   }
 
+  // Clone early so both templateSyntaxParser.parse and computeBranchSegments
+  // receive a mutable copy, even when the source is a frozen export.
+  const syntaxItems = normalizeSyntax(parserOptions.templateEngineSyntax);
+
   /** @type {any} */
   let tokenAdapter = undefined;
+  let frontmatterOffset = 0;
+
   if (parserOptions.frontmatter) {
     const result = parseFrontmatterContent(code);
     if (result) {
       html = result.html;
+      frontmatterOffset = result.index;
       const lineOffset = result.line - 1;
       tokenAdapter = {
         /** @param {any} token */
@@ -55,7 +96,7 @@ function getOptions(code, parserOptions) {
   let templateInfos = undefined;
   if (parserOptions.templateEngineSyntax) {
     templateInfos = templateSyntaxParser.parse(html, {
-      syntax: parserOptions.templateEngineSyntax,
+      syntax: syntaxItems, // ← use the clone, not the frozen original
     }).syntax;
   }
 
@@ -74,11 +115,15 @@ function getOptions(code, parserOptions) {
         rawContentTags,
       },
       html,
+      syntaxItems,
+      frontmatterOffset,
     };
   }
   return {
     options: undefined,
     html,
+    syntaxItems,
+    frontmatterOffset,
   };
 }
 

package/node_modules/@html-eslint/parser/lib/parser.js

@@ -1,4 +1,5 @@
 /**
+ * @import {TemplateSyntax} from "@html-eslint/template-syntax-parser"
  * @import {Linter} from "eslint"
  * @import {
  *   HTMLProgram,
@@ -11,6 +12,10 @@ const { traverse, traverseCss } = require("./traverse");
 const { NODE_TYPES } = require("./node-types");
 const { getOptions } = require("./options");
 const { parse: parseCSS, toPlainObject } = require("css-tree");
+const {
+  computeBranchSegments,
+  getControlTokenRanges,
+} = require("./branch-annotation");
 
 /**
  * @param {string} code
@@ -18,8 +23,12 @@ const { parse: parseCSS, toPlainObject } = require("css-tree");
  * @returns {Linter.ESLintParseResult}
  */
 module.exports.parseForESLint = function parseForESLint(code, parserOptions) {
-  const { options, html } = getOptions(code, parserOptions);
+  const { options, html, syntaxItems, frontmatterOffset } = getOptions(
+    code,
+    parserOptions
+  );
   const { ast, tokens } = parse(html, options);
+
   /** @type {HTMLProgram} */
   const programNode = {
     type: "Program",
@@ -37,6 +46,58 @@ module.exports.parseForESLint = function parseForESLint(code, parserOptions) {
     comments: [],
   };
 
+  // Compute branch segments from the template token list produced by
+  // @html-eslint/template-syntax-parser.  Rules (no-duplicate-id, etc.) read
+  // these segments to decide whether "duplicate" nodes are actually confined
+  // to mutually exclusive runtime branches.
+  //
+  // templateInfos ranges are relative to `html` (frontmatter-stripped source).
+  // AST node ranges are relative to the original `code` (via tokenAdapter).
+  // We therefore add frontmatterOffset to each segment after computing them.
+  // options.templateInfos is typed as TemplateInfo[] by es-html-parser's
+  // declarations, but at runtime it is always TemplateSyntax[] produced by
+  // @html-eslint/template-syntax-parser.  The cast is safe.
+  const templateInfos = /** @type {TemplateSyntax[]} */ (
+    (options && options.templateInfos) || []
+  );
+
+  if (templateInfos.length > 0 && syntaxItems.length > 0) {
+    const rawSegments = computeBranchSegments(templateInfos, html, syntaxItems);
+    const rawControlRanges = getControlTokenRanges(
+      templateInfos,
+      html,
+      syntaxItems
+    );
+    // @ts-ignore — branchSegments is not part of the typed HTMLProgram
+    // definition, but rules access it dynamically via sourceCode.ast.
+    programNode.branchSegments =
+      frontmatterOffset === 0
+        ? rawSegments
+        : rawSegments.map((seg) => ({
+            groupId: seg.groupId,
+            branchIndex: seg.branchIndex,
+            start: seg.start + frontmatterOffset,
+            end: seg.end + frontmatterOffset,
+          }));
+    // @ts-ignore — branchControlRanges is not part of the typed HTMLProgram
+    // definition. Rules use it to tell a branch-control template token
+    // (e.g. {% if %} / {% else %} / {% endif %}) apart from a plain
+    // value-interpolation token (e.g. {{ name }}) when a template token
+    // ends up glued onto adjacent text with no separating whitespace.
+    programNode.branchControlRanges =
+      frontmatterOffset === 0
+        ? rawControlRanges
+        : rawControlRanges.map(([start, end]) => [
+            start + frontmatterOffset,
+            end + frontmatterOffset,
+          ]);
+  } else {
+    // @ts-ignore
+    programNode.branchSegments = [];
+    // @ts-ignore
+    programNode.branchControlRanges = [];
+  }
+
   traverse(programNode, (node) => {
     if (node.type === NODE_TYPES.CommentContent) {
       programNode.comments.push({

package/node_modules/@html-eslint/parser/lib/template-engine-syntax-preset.js

@@ -1,17 +1,130 @@
 /** @import {SyntaxConfig} from "@html-eslint/template-syntax-parser" */
 
+/**
+ * Branch configuration for a template block delimiter.
+ *
+ * The template-syntax-parser ignores unknown properties on SyntaxConfigItem, so
+ * adding `branch` here is fully backwards-compatible.
+ *
+ * Patterns are matched against the raw content between the opening and closing
+ * delimiters of each template token, e.g. the content of `{% if foo %}` is " if
+ * foo " (including surrounding whitespace).
+ *
+ * @typedef {{
+ *   start: RegExp; // matches if-opening tokens  (e.g. " if cond ")
+ *   continue: RegExp; // matches branch-separator tokens (elseif / else)
+ *   end: RegExp; // matches if-closing tokens  (e.g. " endif ")
+ *   blockOpen?: RegExp; // matches other block-openers (for, macro, …)
+ *   blockClose?: RegExp; // matches the matching closers (endfor, …)
+ * }} BranchConfig
+ *   BlockOpen / blockClose are needed to prevent an `else` or `elif` that belongs
+ *   to a `for` / `macro` / etc. block from being misclassified as an `else`
+ *   belonging to an enclosing `if` block.
+ */
+
+// ---------------------------------------------------------------------------
+// HANDLEBAR
+// ---------------------------------------------------------------------------
+
 /** @type {SyntaxConfig} */
 const HANDLEBAR = {
   "{{": "}}",
 };
 
-/** @type {SyntaxConfig} */
+/**
+ * Handlebars with conditional branch-awareness. Use this instead of HANDLEBAR
+ * when you want duplicate nodes that appear in separate `{{#if}}` / `{{else}}`
+ * branches to be silently ignored.
+ *
+ * Must be used as an array (SyntaxConfigItem[]) rather than the shorthand
+ * Record form, because the Record form has no place to carry branch patterns.
+ *
+ * @type {{ open: string; close: string; branch: BranchConfig }[]}
+ */
+const HANDLEBAR_EXTENDED = [
+  {
+    open: "{{",
+    close: "}}",
+    branch: {
+      start: /^\s*#if\b/,
+      continue: /^\s*else\b/,
+      end: /^\s*\/if\b/,
+      // Any block helper other than #if / /if may carry its own {{else}}.
+      blockOpen: /^\s*#(?!if\b)/,
+      blockClose: /^\s*\/(?!if\b)/,
+    },
+  },
+];
+
+// ---------------------------------------------------------------------------
+// TWIG
+// ---------------------------------------------------------------------------
+
+/**
+ * Twig branch patterns. Handles optional whitespace-control dashes: {%- ... -%}
+ * The `-` appears as the first non-space character of the token content.
+ *
+ * @type {BranchConfig}
+ */
+const TWIG_BRANCH = {
+  start: /^\s*-?\s*if\b/,
+  continue: /^\s*-?\s*(elseif|else)\b/,
+  end: /^\s*-?\s*endif\b/,
+  blockOpen: /^\s*-?\s*(for|block|macro|embed|autoescape|sandbox|with)\b/,
+  blockClose: /^\s*-?\s*end(for|block|macro|embed|autoescape|sandbox|with)\b/,
+};
+
+/**
+ * @type {{
+ *   open: string;
+ *   close: string;
+ *   isComment?: boolean;
+ *   branch?: BranchConfig;
+ * }[]}
+ */
 const TWIG = [
   { open: "{{", close: "}}" },
-  { open: "{%", close: "%}" },
+  { open: "{%", close: "%}", branch: TWIG_BRANCH },
   { open: "{#", close: "#}", isComment: true },
 ];
 
+// ---------------------------------------------------------------------------
+// NUNJUCKS
+// Identical delimiter syntax to Twig but uses `elif` instead of `elseif`,
+// and its block keyword inventory differs slightly.
+// ---------------------------------------------------------------------------
+
+/**
+ * @type {{
+ *   open: string;
+ *   close: string;
+ *   isComment?: boolean;
+ *   branch?: BranchConfig;
+ * }[]}
+ */
+const NUNJUCKS = [
+  { open: "{{", close: "}}" },
+  {
+    open: "{%",
+    close: "%}",
+    branch: {
+      start: /^\s*-?\s*if\b/,
+      continue: /^\s*-?\s*(elif|else)\b/,
+      end: /^\s*-?\s*endif\b/,
+      blockOpen: /^\s*-?\s*(for|block|macro|call|set)\b/,
+      blockClose: /^\s*-?\s*end(for|block|macro|call|set)\b/,
+    },
+  },
+  { open: "{#", close: "#}", isComment: true },
+];
+
+// ---------------------------------------------------------------------------
+// ERB
+// Not branch-aware: ERB's `end` keyword is shared by every block type
+// (if, unless, while, each, …), making reliable if-block tracking impossible
+// without a full Ruby expression parser.
+// ---------------------------------------------------------------------------
+
 /** @type {SyntaxConfig} */
 const ERB = {
   "<%": "%>",
@@ -19,6 +132,8 @@ const ERB = {
 
 module.exports = {
   HANDLEBAR,
+  HANDLEBAR_EXTENDED,
   TWIG,
+  NUNJUCKS,
   ERB,
 };

package/node_modules/@html-eslint/parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/parser",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "description": "Parser for @html-eslint/eslint-plugin",
   "author": {
     "name": "yeonjuan",
@@ -38,13 +38,13 @@
     "lint"
   ],
   "dependencies": {
-    "@html-eslint/template-syntax-parser": "^0.64.0",
-    "@html-eslint/types": "^0.64.0",
+    "@html-eslint/template-syntax-parser": "^0.65.0",
+    "@html-eslint/types": "^0.65.0",
     "css-tree": "^3.1.0",
     "es-html-parser": "0.3.1"
   },
   "devDependencies": {
     "@types/css-tree": "^2.3.11"
   },
-  "gitHead": "d0babaf320a0d5c3b72f6d8c7bf49b2841a0b84f"
+  "gitHead": "9557d60cbcb4fcfb1c21e11bbe802af3e83cc1ff"
 }