1/**
2 * Inline, in-file ignore directives — eslint-disable-style waivers that live at
3 * the point they apply and travel with the artifact instead of (or alongside)
4 * an ignore in `.impeccable/config.json`.
5 *
6 * A config ignore is the right default for repo-wide policy. This complements it
7 * for the one case config can't cover: a waiver that belongs to a single file and
8 * needs to follow that file when it leaves the repo — a generated/exported
9 * standalone document, an emailed HTML file, a snippet scanned out of context.
10 *
11 * Comment-syntax-agnostic: the directive is a raw token matched anywhere on a
12 * line, so the same marker works across every comment style impeccable scans —
13 * `//`, `/* *\/`, `<!-- -->`, `#`, `{/* *\/}`, `{# #}`. Trailing comment closers
14 * are stripped before the rule list is parsed.
15 *
16 * Syntax (reason optional; eslint `--` or biome `:` separator):
17 *
18 *   impeccable-disable <rule>[, <rule>...] [-- reason]   whole file
19 *   impeccable-disable-line <rule>...      [-- reason]   the same line
20 *   impeccable-disable-next-line <rule>... [-- reason]   the following line
21 *   impeccable-disable                                   bare / `*` = every rule
22 *
23 * Examples:
24 *
25 *   <!-- impeccable-disable overused-font -- exported brand doc, font is first-party -->
26 *   .brand { font-family: Inter; } /* impeccable-disable-line overused-font *\/
27 *   // impeccable-disable-next-line bounce-easing: intentional playful affordance
28 *
29 * Behavior is suppression, for parity with config ignores: a matched directive
30 * drops the finding. The inline reason is self-documenting in the diff; it is not
31 * required and is discarded at scan time (only used here to keep reason words out
32 * of the parsed rule list).
33 */
34 
35const DIRECTIVE_RE = /impeccable-(disable-next-line|disable-line|disable)\b[ \t]*([^\n\r]*)/gi;
36 
37// Trailing comment closers, so `*/`, `*/}`, `-->`, `*}`, `#}`, `%>`, `}}` don't
38// leak into the rule list. Anchored to end-of-line; the leading `\s*` mops up the
39// space before the closer. `--+>` covers `-->` and any longer dash run.
40const TRAILING_CLOSER_RE = /\s*(?:\*\/\}?|--+>|\*\}|#\}|%>|\}\})\s*$/;
41 
42function normalizeRule(token) {
43  return String(token || '').trim().toLowerCase();
44}
45 
46// Split the directive remainder into rule tokens, dropping any human reason that
47// follows an eslint-style `--` or biome-style `:` separator. Rule ids only ever
48// contain single hyphens (`overused-font`, `bounce-easing`), so `--` and `:`
49// are unambiguous separators.
50function parseRuleList(remainder) {
51  let text = String(remainder || '').replace(TRAILING_CLOSER_RE, '').trim();
52  // Cut off a human reason at the first `--` (eslint) or `:` (biome) separator.
53  const reasonSep = text.match(/\s*(?:--+|:)\s*/);
54  if (reasonSep) text = text.slice(0, reasonSep.index);
55  const tokens = text.split(/[\s,]+/).map(normalizeRule).filter(Boolean);
56  if (tokens.length === 0 || tokens.includes('*')) return ['*'];
57  return tokens;
58}
59 
60function addRules(set, rules) {
61  for (const rule of rules) set.add(rule);
62}
63 
64function getSet(map, key) {
65  let set = map.get(key);
66  if (!set) {
67    set = new Set();
68    map.set(key, set);
69  }
70  return set;
71}
72 
73/**
74 * Parse every inline ignore directive in a file's raw text.
75 *
76 * Returns sets keyed by the 1-based line the directive *targets* so matching is a
77 * direct lookup:
78 *   - file:     rules disabled for the whole file
79 *   - line:     line -> rules disabled on that exact line (disable-line)
80 *   - nextLine: line -> rules disabled on that line (disable-next-line on line-1)
81 *
82 * `*` in any set means "every rule".
83 */
84function parseInlineIgnores(content) {
85  const result = { file: new Set(), line: new Map(), nextLine: new Map() };
86  const text = typeof content === 'string' ? content : '';
87  // Cheap bail-out: the substring must be present for any directive to exist.
88  // Case-insensitive to match DIRECTIVE_RE's `i` flag (e.g. `Impeccable-Disable`).
89  if (!/impeccable-disable/i.test(text)) return result;
90 
91  // Split on `\n` only, exactly as detectText numbers lines, so directive line
92  // keys line up with finding `line` values (incl. on `\r`-only line endings).
93  // The directive regex excludes `\r`, so a trailing `\r` on `\r\n` files is
94  // never captured into the rule list.
95  const lines = text.split('\n');
96  for (let i = 0; i < lines.length; i++) {
97    DIRECTIVE_RE.lastIndex = 0;
98    let m;
99    while ((m = DIRECTIVE_RE.exec(lines[i])) !== null) {
100      const variant = m[1].toLowerCase();
101      const rules = parseRuleList(m[2]);
102      if (variant === 'disable') {
103        addRules(result.file, rules);
104      } else if (variant === 'disable-line') {
105        addRules(getSet(result.line, i + 1), rules);
106      } else {
107        // disable-next-line on line i+1 targets line i+2.
108        addRules(getSet(result.nextLine, i + 2), rules);
109      }
110    }
111  }
112  return result;
113}
114 
115function setMatches(set, rule) {
116  return Boolean(set) && (set.has('*') || set.has(rule));
117}
118 
119function isInlineIgnored(finding, directives) {
120  const rule = normalizeRule(finding && finding.antipattern);
121  if (!rule) return false;
122  if (setMatches(directives.file, rule)) return true;
123  const line = Number(finding && finding.line) || 0;
124  if (line > 0) {
125    if (setMatches(directives.line.get(line), rule)) return true;
126    if (setMatches(directives.nextLine.get(line), rule)) return true;
127  }
128  return false;
129}
130 
131function hasDirectives(directives) {
132  return directives.file.size > 0 || directives.line.size > 0 || directives.nextLine.size > 0;
133}
134 
135/**
136 * Drop findings waived by an inline directive in the same file's source text.
137 * Findings without a usable line number (e.g. static-HTML page-level findings)
138 * are only matched by whole-file directives — which is the standalone-document
139 * case this primitive exists for.
140 */
141function applyInlineIgnores(findings, content) {
142  if (!Array.isArray(findings) || findings.length === 0) return findings;
143  const directives = parseInlineIgnores(content);
144  if (!hasDirectives(directives)) return findings;
145  return findings.filter((finding) => !isInlineIgnored(finding, directives));
146}
147 
148export { parseInlineIgnores, applyInlineIgnores, isInlineIgnored };
149