1import fs from 'node:fs';
2import path from 'node:path';
3 
4import { GENERIC_FONTS, OVERUSED_FONTS } from '../../shared/constants.mjs';
5import {
6  checkSourceDesignSystem,
7  collectStaticDesignSystemFindings,
8  mergeDesignSystemFindings,
9} from '../../design-system.mjs';
10import { isFullPage } from '../../shared/page.mjs';
11import { finding } from '../../findings.mjs';
12import { profileFindings, profileStep, profileStepAsync } from '../../profile/profiler.mjs';
13import {
14  checkElementBorders,
15  checkElementClippedOverflow,
16  checkElementColors,
17  checkElementGlow,
18  checkElementGptBorderShadow,
19  checkElementHeroEyebrow,
20  checkElementIconTile,
21  checkElementItalicSerif,
22  checkElementMotion,
23  checkElementOversizedH1,
24  checkElementQuality,
25  checkCreamPalette,
26  checkHtmlPatterns,
27  checkPageLayout,
28  checkPageQualityFromDoc,
29  checkRepeatedSectionKickersFromDoc,
30  resolveBackground,
31  resolveBorderRadiusPx,
32} from '../../rules/checks.mjs';
33import { filterByProviders } from '../../registry/antipatterns.mjs';
34import { detectText, runTextContentAnalyzers } from '../regex/detect-text.mjs';
35import {
36  StaticDocument,
37  buildStaticStyleMap,
38  buildStaticWindow,
39  collectStaticCssText,
40} from './css-cascade.mjs';
41 
42function checkStaticPageTypography(document, window) {
43  const findings = [];
44  const fonts = new Set();
45  const overusedFound = new Set();
46  for (const el of document.querySelectorAll('p, h1, h2, h3, h4, h5, h6, li, td, th, dd, blockquote, figcaption, a, button, label, span, div')) {
47    const hasText = el.childNodes.some(n => n.nodeType === 3 && n.textContent.trim().length > 0);
48    if (!hasText) continue;
49    const ff = window.getComputedStyle(el).fontFamily || '';
50    const stack = ff.split(',').map(f => f.trim().replace(/^['"]|['"]$/g, '').toLowerCase());
51    const primary = stack.find(f => f && !GENERIC_FONTS.has(f));
52    if (!primary) continue;
53    fonts.add(primary);
54    if (OVERUSED_FONTS.has(primary)) overusedFound.add(primary);
55  }
56  for (const font of overusedFound) {
57    findings.push({ id: 'overused-font', snippet: `Primary font: ${font}` });
58  }
59  if (fonts.size === 1 && document.querySelectorAll('*').length >= 20) {
60    findings.push({ id: 'single-font', snippet: `only font used is ${[...fonts][0]}` });
61  }
62  const sizes = new Set();
63  for (const el of document.querySelectorAll('h1, h2, h3, h4, h5, h6, p, span, a, li, td, th, label, button, div')) {
64    const fontSize = parseFloat(window.getComputedStyle(el).fontSize);
65    if (fontSize >= 8 && fontSize < 200) sizes.add(Math.round(fontSize * 10) / 10);
66  }
67  if (sizes.size >= 3) {
68    const sorted = [...sizes].sort((a, b) => a - b);
69    const ratio = sorted[sorted.length - 1] / sorted[0];
70    if (ratio < 2.0) {
71      findings.push({ id: 'flat-type-hierarchy', snippet: `Sizes: ${sorted.map(s => s + 'px').join(', ')} (ratio ${ratio.toFixed(1)}:1)` });
72    }
73  }
74  return findings;
75}
76 
77function checkElementBrokenImage(el) {
78  const src = (el.getAttribute && el.getAttribute('src')) ?? el.attribs?.src;
79  // Missing src attribute entirely
80  if (src === undefined || src === null) {
81    return [{ id: 'broken-image', snippet: '<img> with no src attribute' }];
82  }
83  const trimmed = String(src).trim();
84  // Empty or placeholder-only src values
85  if (trimmed === '' || trimmed === '#') {
86    return [{ id: 'broken-image', snippet: `<img src="${src}">` }];
87  }
88  return [];
89}
90 
91const STATIC_ELEMENT_RULES = [
92  { id: 'border-rules', selector: '*', run: (el, tag, style, window, customPropMap) => checkElementBorders(tag, style, null, resolveBorderRadiusPx(el, style, parseFloat(style.width) || 0, window)) },
93  { id: 'color-rules', selector: '*', run: (el, tag, style, window, customPropMap) => checkElementColors(el, style, tag, window, customPropMap, false) },
94  { id: 'dark-glow', selector: '*', run: (el, tag, style, window, customPropMap) => checkElementGlow(tag, style, resolveBackground(el.parentElement || el, window, customPropMap)) },
95  { id: 'motion-rules', selector: '*', run: (el, tag, style) => checkElementMotion(tag, style) },
96  { id: 'icon-tile-stack', selector: 'h1,h2,h3,h4,h5,h6', run: (el, tag, _style, window) => checkElementIconTile(el, tag, window) },
97  { id: 'italic-serif-display', selector: 'h1,h2', run: (el, tag, style) => checkElementItalicSerif(el, style, tag) },
98  { id: 'hero-eyebrow-chip', selector: 'h1', run: (el, tag, style, window, customPropMap) => checkElementHeroEyebrow(el, style, tag, window, customPropMap) },
99  { id: 'broken-image', selector: 'img', run: (el) => checkElementBrokenImage(el) },
100  { id: 'quality-rules', selector: '*', run: (el, tag, style, window) => checkElementQuality(el, style, tag, window) },
101  { id: 'oversized-h1', selector: 'h1', run: (el, tag, style, window) => checkElementOversizedH1(el, style, tag, window) },
102  { id: 'clipped-overflow-container', selector: '*', run: (el, tag, style, window) => checkElementClippedOverflow(el, style, tag, window) },
103  { id: 'gpt-thin-border-wide-shadow', selector: '*', run: (el, tag, style) => checkElementGptBorderShadow(el, style) },
104];
105 
106async function detectHtml(filePath, options = {}) {
107  const profile = options?.profile;
108  const html = profileStep(profile, {
109    engine: 'static-html',
110    phase: 'setup',
111    ruleId: 'read-html',
112    target: filePath,
113  }, () => fs.readFileSync(filePath, 'utf-8'));
114 
115  let modules;
116  try {
117    modules = await profileStepAsync(profile, {
118      engine: 'static-html',
119      phase: 'setup',
120      ruleId: 'import-static-parser',
121      target: filePath,
122    }, async () => {
123      const [htmlparser2, cssSelect, csstree, domutils] = await Promise.all([
124        import('htmlparser2'),
125        import('css-select'),
126        import('css-tree'),
127        import('domutils'),
128      ]);
129      return {
130        parseDocument: htmlparser2.parseDocument,
131        selectAll: cssSelect.selectAll,
132        selectOne: cssSelect.selectOne,
133        is: cssSelect.is,
134        csstree,
135        domutils,
136      };
137    });
138  } catch {
139    return detectText(html, filePath, options);
140  }
141 
142  const resolvedPath = path.resolve(filePath);
143  const fileDir = path.dirname(resolvedPath);
144  const root = profileStep(profile, {
145    engine: 'static-html',
146    phase: 'parse-html',
147    ruleId: 'parse-document',
148    target: filePath,
149  }, () => modules.parseDocument(html, { lowerCaseAttributeNames: false, lowerCaseTags: true }));
150 
151  const cssText = collectStaticCssText(root, fileDir, profile, filePath, modules);
152  const document = new StaticDocument(root, modules);
153  buildStaticStyleMap(root, document, cssText, modules, profile, filePath);
154  const window = buildStaticWindow(document);
155 
156  const customPropMap = null;
157 
158  const findings = [];
159  const runElementCheck = (ruleId, callback) => profile
160    ? profileFindings(profile, { engine: 'static-html', phase: 'element', ruleId, target: filePath }, callback)
161    : callback();
162 
163  const visitedByRule = new Map();
164  for (const rule of STATIC_ELEMENT_RULES) {
165    const elements = document.querySelectorAll(rule.selector);
166    visitedByRule.set(rule.id, elements.length);
167    for (const el of elements) {
168      const tag = el.tagName.toLowerCase();
169      const style = window.getComputedStyle(el);
170      for (const f of runElementCheck(rule.id, () => rule.run(el, tag, style, window, customPropMap))) {
171        findings.push(finding(f.id, filePath, f.snippet));
172      }
173    }
174  }
175 
176  if (options?.designSystem) {
177    const sourceDesignFindings = profileFindings(profile, {
178      engine: 'static-html',
179      phase: 'source',
180      ruleId: 'design-system',
181      target: filePath,
182    }, () => checkSourceDesignSystem(html, filePath, { designSystem: options.designSystem }));
183    const staticDesignFindings = profileFindings(profile, {
184      engine: 'static-html',
185      phase: 'page',
186      ruleId: 'design-system',
187      target: filePath,
188    }, () => collectStaticDesignSystemFindings(document, window, filePath, options.designSystem));
189    findings.push(...mergeDesignSystemFindings(staticDesignFindings, sourceDesignFindings));
190  }
191 
192  if (isFullPage(html)) {
193    const runPageCheck = (ruleId, callback) => profile
194      ? profileFindings(profile, { engine: 'static-html', phase: 'page', ruleId, target: filePath }, callback)
195      : callback();
196    for (const f of runPageCheck('typography-rules', () => checkStaticPageTypography(document, window))) {
197      findings.push(finding(f.id, filePath, f.snippet));
198    }
199    for (const f of runPageCheck('repeated-section-kickers', () => checkRepeatedSectionKickersFromDoc(document, window))) {
200      findings.push(finding(f.id, filePath, f.snippet));
201    }
202    for (const f of runPageCheck('layout-rules', () => checkPageLayout(document, window))) {
203      findings.push(finding(f.id, filePath, f.snippet));
204    }
205    for (const f of runPageCheck('cream-palette', () => checkCreamPalette(document, window))) {
206      findings.push(finding(f.id, filePath, f.snippet));
207    }
208    for (const f of runPageCheck('skipped-heading', () => checkPageQualityFromDoc(document))) {
209      findings.push(finding(f.id, filePath, f.snippet));
210    }
211    for (const f of runPageCheck('html-patterns', () => checkHtmlPatterns(html).filter(item =>
212      item.id !== 'bounce-easing' && item.id !== 'layout-transition'
213    ))) {
214      findings.push(finding(f.id, filePath, f.snippet));
215    }
216    // Text-content analyzers (em-dash overuse, marketing buzzwords,
217    // numbered section markers, aphoristic cadence) live in the regex
218    // engine. Call them from here so .html files get the same coverage
219    // as .css/.tsx files. These are scoped to text content only and
220    // don't overlap with static-html's element/page rules.
221    for (const f of runPageCheck('text-content', () => runTextContentAnalyzers(html, filePath, options))) {
222      findings.push(finding(f.antipattern, filePath, f.snippet));
223    }
224  }
225 
226  return filterByProviders(findings, options.providers);
227}
228 
229export { checkStaticPageTypography, STATIC_ELEMENT_RULES, detectHtml };
230