402 lines
27 KiB
JavaScript
402 lines
27 KiB
JavaScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { staticStrings, localConstants } from './guard-theme-analysis.mjs';
|
|
|
|
export const verdict = values => values.includes('FAIL') ? 'FAIL' : values.includes('NOT VERIFIED') ? 'NOT VERIFIED' : 'PASS';
|
|
const lineOf = n => n?.loc?.start?.line ?? n?.source?.start?.line ?? 1;
|
|
const rawColor = /#[\da-f]{3,8}\b|\b(?:rgb|hsl)a?\(/i;
|
|
const geometry = /^(?:padding|margin|gap|row-gap|column-gap|border-(?:(?:top|bottom)-(?:left|right)-)?radius)(?:-|$)/;
|
|
function withoutVariables(value) {
|
|
let result = '';
|
|
for (let i = 0; i < value.length; i++) {
|
|
if (value.slice(i, i + 4) !== 'var(') { result += value[i]; continue; }
|
|
let depth = 1;
|
|
i += 3;
|
|
while (++i < value.length && depth) { if (value[i] === '(') depth++; else if (value[i] === ')') depth--; }
|
|
i--;
|
|
}
|
|
return result;
|
|
}
|
|
function knownStyleStrings(node, constants, seen = new Set()) {
|
|
const finite = staticStrings(node, constants);
|
|
if (finite) return finite;
|
|
if (node?.type === 'ConditionalExpression') return [...knownStyleStrings(node.consequent, constants, seen), ...knownStyleStrings(node.alternate, constants, seen)];
|
|
if (node?.type === 'TemplateLiteral') return node.quasis.map(q => q.value.cooked ?? q.value.raw);
|
|
if (node?.type === 'Identifier' && constants.has(node.name) && !seen.has(node.name)) return knownStyleStrings(constants.get(node.name), constants, new Set([...seen, node.name]));
|
|
return [];
|
|
}
|
|
|
|
const propertyName = n => n?.computed ? n.property?.value : n?.property?.name;
|
|
const nodeName = n => n?.name ?? n?.value;
|
|
const classKeys = new Set(['className', 'class']);
|
|
const joiners = new Set(['cn', 'clsx', 'classNames', 'twMerge']);
|
|
const helperPackages = new Set(['cn', 'clsx', 'classnames', 'tailwind-merge', 'class-variance-authority']);
|
|
const helperName = (context, callee) => {
|
|
if (context.shadowed?.has(callee.name)) return null;
|
|
const imported = context.imports?.get(callee.name);
|
|
return imported && helperPackages.has(imported.source) ? imported.name === 'default' ? imported.source === 'classnames' ? 'classNames' : imported.source : imported.name : null;
|
|
};
|
|
const mergeCandidates = results => ({ values: results.flatMap(r => r.values), unknown: results.some(r => r.unknown) });
|
|
const unknownClasses = () => ({ values: [], unknown: true });
|
|
const functionNodes = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ObjectMethod', 'ClassMethod', 'ClassPrivateMethod']);
|
|
function bindingNames(node) {
|
|
if (!node) return [];
|
|
if (node.type === 'Identifier') return [node.name];
|
|
if (node.type === 'RestElement') return bindingNames(node.argument);
|
|
if (node.type === 'AssignmentPattern') return bindingNames(node.left);
|
|
if (node.type === 'ArrayPattern') return node.elements.flatMap(bindingNames);
|
|
if (node.type === 'ObjectPattern') return node.properties.flatMap(p => bindingNames(p.type === 'RestElement' ? p.argument : p.value));
|
|
return [];
|
|
}
|
|
|
|
// Only expressions feeding a class binding are evidence. Never search comments,
|
|
// arbitrary strings, CSS selectors or variant names for a substring match.
|
|
function classCandidates(node, context, resolveBinding, internal = false, seen = new Set()) {
|
|
if (!node) return unknownClasses();
|
|
const finite = staticStrings(node, context.constants);
|
|
if (finite) return { values: finite, unknown: false };
|
|
const recurse = n => classCandidates(n, context, resolveBinding, internal, seen);
|
|
if (['JSXExpressionContainer', 'TSAsExpression', 'TSNonNullExpression', 'ParenthesizedExpression'].includes(node.type)) return recurse(node.expression);
|
|
if (['BooleanLiteral', 'NullLiteral'].includes(node.type)) return { values: [], unknown: false };
|
|
if (node.type === 'ConditionalExpression') return mergeCandidates([recurse(node.consequent), recurse(node.alternate)]);
|
|
if (node.type === 'LogicalExpression') return node.operator === '&&' ? recurse(node.right) : mergeCandidates([recurse(node.left), recurse(node.right)]);
|
|
if (node.type === 'ArrayExpression') return mergeCandidates(node.elements.filter(Boolean).map(recurse));
|
|
if (node.type === 'ObjectExpression') return mergeCandidates(node.properties.map(p => {
|
|
if (p.type !== 'ObjectProperty') return unknownClasses();
|
|
if (p.value.type === 'BooleanLiteral' && !p.value.value || p.value.type === 'NullLiteral') return { values: [], unknown: false };
|
|
return p.computed ? recurse(p.key) : { values: [String(nodeName(p.key))], unknown: false };
|
|
}));
|
|
if (node.type === 'Identifier') {
|
|
const key = `${context.file}:${node.name}`;
|
|
if (seen.has(key)) return unknownClasses();
|
|
const binding = resolveBinding(context, node.name);
|
|
if (binding?.node) return classCandidates(binding.node, binding.context, resolveBinding, internal, new Set([...seen, key]));
|
|
// Public className forwarding is already checked at consumer call sites.
|
|
if (internal && context.forwardedClasses.has(node.name) && !context.declared.has(node.name)) return { values: [], unknown: false };
|
|
return unknownClasses();
|
|
}
|
|
if (node.type === 'MemberExpression' && internal && classKeys.has(propertyName(node)) && context.forwardedProps.has(node.object?.name) && !context.declared.has(node.object.name)) return { values: [], unknown: false };
|
|
if (node.type === 'CallExpression') {
|
|
const name = node.callee.name ?? propertyName(node.callee);
|
|
const helper = helperName(context, node.callee);
|
|
if (joiners.has(helper)) return mergeCandidates(node.arguments.map(recurse));
|
|
if (helper === 'cva') {
|
|
const config = node.arguments[1];
|
|
const results = node.arguments[0] ? [recurse(node.arguments[0])] : [];
|
|
if (config && config.type !== 'ObjectExpression') results.push(unknownClasses());
|
|
for (const p of config?.properties ?? []) {
|
|
if (p.type !== 'ObjectProperty' || p.computed) { results.push(unknownClasses()); continue; }
|
|
if (nodeName(p.key) === 'variants') {
|
|
if (p.value.type !== 'ObjectExpression') { results.push(unknownClasses()); continue; }
|
|
for (const variant of p.value.properties) {
|
|
if (variant.type !== 'ObjectProperty' || variant.value.type !== 'ObjectExpression') { results.push(unknownClasses()); continue; }
|
|
results.push(...variant.value.properties.map(option => option.type === 'ObjectProperty' ? recurse(option.value) : unknownClasses()));
|
|
}
|
|
}
|
|
if (nodeName(p.key) === 'compoundVariants') {
|
|
if (p.value.type !== 'ArrayExpression') { results.push(unknownClasses()); continue; }
|
|
for (const item of p.value.elements) {
|
|
if (item?.type !== 'ObjectExpression') { results.push(unknownClasses()); continue; }
|
|
for (const field of item.properties) {
|
|
if (field.type !== 'ObjectProperty' || field.computed) results.push(unknownClasses());
|
|
else if (classKeys.has(nodeName(field.key))) results.push(recurse(field.value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return mergeCandidates(results);
|
|
}
|
|
const binding = node.callee.type === 'Identifier' ? resolveBinding(context, node.callee.name) : null;
|
|
if (binding?.node?.type === 'CallExpression' && helperName(binding.context, binding.node.callee) === 'cva') {
|
|
const results = [classCandidates(binding.node, binding.context, resolveBinding, internal, seen)];
|
|
for (const arg of node.arguments) {
|
|
if (arg.type !== 'ObjectExpression') { results.push(unknownClasses()); continue; }
|
|
for (const p of arg.properties) {
|
|
if (p.type !== 'ObjectProperty' || p.computed) results.push(unknownClasses());
|
|
else if (classKeys.has(nodeName(p.key))) results.push(recurse(p.value));
|
|
}
|
|
}
|
|
return mergeCandidates(results);
|
|
}
|
|
if (name === 'trim') return recurse(node.callee.object);
|
|
if (name === 'join' && node.arguments[0]?.value === ' ') return recurse(node.callee.object);
|
|
// An unrelated function named cn/clsx is opaque, not a proven joiner.
|
|
if (joiners.has(name)) return mergeCandidates([...node.arguments.map(recurse), unknownClasses()]);
|
|
}
|
|
return unknownClasses();
|
|
}
|
|
|
|
function implementationClasses(files, parseJS, walk, usedComponents) {
|
|
const classes = new Set(), modules = new Map(), fileSet = new Set(files.map(f => path.resolve(f)));
|
|
const resolveFile = (file, spec) => {
|
|
if (!spec?.startsWith('.')) return null;
|
|
const base = path.resolve(path.dirname(file), spec);
|
|
return [base, ...['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx'].map(ext => base + ext), ...(/\.[cm]?js$/.test(base) ? [base.replace(/\.[cm]?js$/, '.ts'), base.replace(/\.[cm]?js$/, '.tsx')] : [])].map(f => path.normalize(f)).find(f => fileSet.has(f));
|
|
};
|
|
for (const file of fileSet) {
|
|
if (!/\.[cm]?[jt]sx?$/.test(file)) continue;
|
|
const context = { file, constants: new Map(), imports: new Map(), exports: new Map(), stars: [], dependencies: new Set(), forwardedClasses: new Set(), forwardedProps: new Set(), declared: new Set(), shadowed: new Set(), parents: new WeakMap(), scopes: new WeakMap(), unknown: false };
|
|
modules.set(file, context);
|
|
try { context.ast = parseJS(fs.readFileSync(file, 'utf8'), file); } catch { context.unknown = true; continue; }
|
|
// Parameter type references (VariantProps<typeof buttonVariants>) are not
|
|
// bindings and must not shadow the immutable class factory they describe.
|
|
for (const stmt of context.ast.program.body) {
|
|
const declaration = stmt.type === 'ExportNamedDeclaration' ? stmt.declaration : stmt;
|
|
if (declaration?.type === 'VariableDeclaration' && declaration.kind === 'const') for (const d of declaration.declarations) if (d.id.type === 'Identifier') context.constants.set(d.id.name, d.init);
|
|
}
|
|
for (const stmt of context.ast.program.body) {
|
|
if (stmt.type === 'ImportDeclaration' && stmt.importKind !== 'type') {
|
|
const dependency = resolveFile(file, stmt.source.value);
|
|
if (stmt.source.value.startsWith('.') && !dependency) context.unknown = true;
|
|
if (dependency) context.dependencies.add(dependency);
|
|
for (const s of stmt.specifiers.filter(s => s.importKind !== 'type')) context.imports.set(s.local.name, { file: dependency, source: stmt.source.value, name: s.type === 'ImportSpecifier' ? nodeName(s.imported) : s.type === 'ImportDefaultSpecifier' ? 'default' : '*' });
|
|
}
|
|
if (stmt.type === 'ExportAllDeclaration' && stmt.exportKind !== 'type') {
|
|
const dependency = resolveFile(file, stmt.source.value);
|
|
context.stars.push(dependency);
|
|
if (dependency) context.dependencies.add(dependency);
|
|
else context.unknown = true;
|
|
}
|
|
if (stmt.type === 'ExportNamedDeclaration' && stmt.exportKind !== 'type') {
|
|
if (stmt.source) {
|
|
const dependency = resolveFile(file, stmt.source.value);
|
|
if (dependency) context.dependencies.add(dependency);
|
|
else if (stmt.source.value.startsWith('.')) context.unknown = true;
|
|
}
|
|
for (const s of stmt.specifiers) context.exports.set(nodeName(s.exported), { file: stmt.source ? resolveFile(file, stmt.source.value) : file, name: nodeName(s.local) });
|
|
if (stmt.declaration?.id) context.exports.set(stmt.declaration.id.name, { file, name: stmt.declaration.id.name });
|
|
for (const d of stmt.declaration?.declarations ?? []) if (d.id.type === 'Identifier') context.exports.set(d.id.name, { file, name: d.id.name });
|
|
}
|
|
if (stmt.type === 'ExportDefaultDeclaration') context.exports.set('default', { file, name: stmt.declaration.id?.name ?? stmt.declaration.name ?? 'default' });
|
|
}
|
|
walk(context.ast, (n, parent) => {
|
|
if (parent) context.parents.set(n, parent);
|
|
if (n.type === 'VariableDeclarator' || functionNodes.has(n.type) && n.id) for (const name of bindingNames(n.id)) {
|
|
context.declared.add(name);
|
|
if (context.imports.has(name)) context.shadowed.add(name);
|
|
if (context.constants.get(name) !== n.init) context.constants.delete(name);
|
|
}
|
|
const params = functionNodes.has(n.type) ? n.params : n.type === 'CatchClause' ? [n.param] : [];
|
|
for (const p of params) for (const name of bindingNames(p)) {
|
|
if (context.imports.has(name)) context.shadowed.add(name);
|
|
context.constants.delete(name);
|
|
}
|
|
});
|
|
}
|
|
const bindingContext = (context, node) => {
|
|
let owner = node;
|
|
while (owner && !functionNodes.has(owner.type)) owner = context.parents.get(owner);
|
|
if (!owner) return context;
|
|
if (context.scopes.has(owner)) return context.scopes.get(owner);
|
|
const scope = { ...context, forwardedClasses: new Set(), forwardedProps: new Set() };
|
|
for (const p of owner.params) {
|
|
if (p.type === 'Identifier') scope.forwardedProps.add(p.name);
|
|
if (p.type === 'ObjectPattern') for (const field of p.properties) {
|
|
if (field.type === 'RestElement' && field.argument.type === 'Identifier') scope.forwardedProps.add(field.argument.name);
|
|
if (field.type !== 'ObjectProperty' || field.computed || !classKeys.has(nodeName(field.key))) continue;
|
|
const binding = field.value.type === 'AssignmentPattern' ? field.value.left : field.value;
|
|
if (binding.type === 'Identifier' && binding.name === nodeName(field.key)) scope.forwardedClasses.add(binding.name);
|
|
}
|
|
}
|
|
context.scopes.set(owner, scope);
|
|
return scope;
|
|
};
|
|
const exported = (file, name, seen = new Set()) => {
|
|
const key = `${file}:${name}`, context = modules.get(file);
|
|
if (!context || seen.has(key)) return null;
|
|
const next = new Set([...seen, key]), binding = context.exports.get(name);
|
|
if (binding) return binding.file === file ? { context, name: binding.name } : exported(binding.file, binding.name, next);
|
|
for (const star of context.stars) { const result = exported(star, name, next); if (result) return result; }
|
|
return null;
|
|
};
|
|
const resolveBinding = (context, name) => {
|
|
if (context.constants.has(name)) return { context, node: context.constants.get(name) };
|
|
const imported = context.imports.get(name), binding = imported?.file && exported(imported.file, imported.name);
|
|
return binding ? resolveBindingLocal(binding.context, binding.name, new Set()) : null;
|
|
};
|
|
function resolveBindingLocal(context, name, seen) {
|
|
const key = `${context.file}:${name}`;
|
|
if (seen.has(key)) return null;
|
|
seen.add(key);
|
|
if (context.constants.has(name)) return { context, node: context.constants.get(name) };
|
|
const imported = context.imports.get(name), binding = imported?.file && exported(imported.file, imported.name);
|
|
return binding ? resolveBindingLocal(binding.context, binding.name, seen) : null;
|
|
}
|
|
for (const context of modules.values()) if (context.ast) walk(context.ast, n => {
|
|
const scope = bindingContext(context, n);
|
|
let value;
|
|
if (n.type === 'JSXAttribute' && classKeys.has(n.name.name)) value = n.value;
|
|
if (n.type === 'CallExpression' && /^(?:createElement|_?jsx|_?jsxs|jsxDEV)$/.test(n.callee.name ?? propertyName(n.callee) ?? '')) for (const p of n.arguments[1]?.properties ?? []) if (p.type === 'ObjectProperty' && !p.computed && classKeys.has(nodeName(p.key))) collect(p.value);
|
|
if (n.type === 'AssignmentPattern' && classKeys.has(n.left.name)) value = n.right;
|
|
if (n.type === 'JSXAttribute' && n.name.name === 'dangerouslySetInnerHTML') context.unknown = true;
|
|
if (n.type === 'JSXSpreadAttribute' && !(scope.forwardedProps.has(n.argument.name) && !context.declared.has(n.argument.name))) context.unknown = true;
|
|
if (n.type === 'CallExpression') {
|
|
const method = propertyName(n.callee);
|
|
if (['setAttribute', 'setAttributeNS', 'insertAdjacentHTML', 'write', 'writeln'].includes(method) || propertyName(n.callee?.object) === 'classList') context.unknown = true;
|
|
if (/^(?:createElement|_?jsx|_?jsxs|jsxDEV)$/.test(n.callee.name ?? method ?? '') && n.arguments[1] && (n.arguments[1].type !== 'ObjectExpression' || n.arguments[1].properties.some(p => p.type === 'SpreadElement' && !(scope.forwardedProps.has(p.argument.name) && !context.declared.has(p.argument.name))))) context.unknown = true;
|
|
}
|
|
if (n.type === 'ImportExpression' || n.type === 'CallExpression' && (n.callee.type === 'Import' || n.callee.name === 'require')) {
|
|
const spec = (n.source ?? n.arguments[0])?.value;
|
|
const dependency = typeof spec === 'string' ? resolveFile(context.file, spec) : null;
|
|
if (dependency) context.dependencies.add(dependency);
|
|
else context.unknown = true;
|
|
}
|
|
if (n.type === 'AssignmentExpression' && ['className', 'innerHTML', 'outerHTML'].includes(propertyName(n.left))) context.unknown = true;
|
|
if (value) collect(value);
|
|
function collect(expr) {
|
|
const result = classCandidates(expr, bindingContext(context, expr), resolveBinding, true);
|
|
for (const v of result.values) for (const token of v.split(/\s+/).filter(Boolean)) classes.add(token);
|
|
context.unknown ||= result.unknown;
|
|
}
|
|
});
|
|
// Preserve the conservative public implementation class catalogue. Unknown
|
|
// generated classes only block exclusions for connected implementation modules.
|
|
const connected = new Set();
|
|
const connect = file => {
|
|
if (!file || connected.has(file)) return;
|
|
connected.add(file);
|
|
for (const dependency of modules.get(file)?.dependencies ?? []) connect(dependency);
|
|
};
|
|
for (const identity of usedComponents) {
|
|
const packageDir = identity.pkg === '@hm-design/ui' ? 'ui' : identity.pkg === '@hm-design/center-graphic' ? 'center-graphic' : null;
|
|
if (!packageDir) continue;
|
|
const entry = [...modules.keys()].find(f => f.replaceAll('\\', '/').endsWith(`/packages/${packageDir}/src/index.ts`));
|
|
const binding = exported(entry, identity.name);
|
|
if (binding) connect(binding.context.file);
|
|
else if (entry) {
|
|
// A missing implementation export/parse cannot prove class absence.
|
|
modules.get(entry).unknown = true;
|
|
connect(entry);
|
|
}
|
|
}
|
|
const unresolvedFiles = [...connected].filter(file => !modules.has(file) || modules.get(file).unknown);
|
|
return { classes, incomplete: unresolvedFiles.length > 0, unresolvedFiles };
|
|
}
|
|
|
|
// A class prefix is not a public Component identity. Only explicit consumer
|
|
// class bindings prove it. A simple positive ancestor absent from the complete
|
|
// entry can bound a rule; dynamic classes/spreads/DOM writes retain strict checks.
|
|
function classScope(records, entries, walk, origin, incomplete, implementationFiles, parseJS) {
|
|
const classes = new Set(), componentClasses = new Map();
|
|
let uncertain = incomplete;
|
|
const usedComponents = [];
|
|
const memberName = n => n?.computed ? n.property?.value : n?.property?.name;
|
|
const collect = (values, component) => {
|
|
if (!values) { uncertain = true; return; }
|
|
for (const value of values) for (const name of value.split(/\s+/).filter(Boolean)) {
|
|
classes.add(name);
|
|
if (component) componentClasses.set(name, component);
|
|
}
|
|
};
|
|
for (const r of records.filter(r => r.ast)) {
|
|
const constants = localConstants(r.ast, walk);
|
|
const imports = new Map();
|
|
for (const stmt of r.ast.program.body) if (stmt.type === 'ImportDeclaration' && stmt.importKind !== 'type') for (const s of stmt.specifiers.filter(s => s.importKind !== 'type')) imports.set(s.local.name, { source: stmt.source.value, name: s.type === 'ImportSpecifier' ? nodeName(s.imported) : s.type === 'ImportDefaultSpecifier' ? 'default' : '*' });
|
|
const shadowed = new Set();
|
|
walk(r.ast, n => {
|
|
const bindings = n.type === 'VariableDeclarator' ? [n.id] : functionNodes.has(n.type) ? [...n.params, n.id] : n.type === 'CatchClause' ? [n.param] : [];
|
|
for (const binding of bindings) for (const name of bindingNames(binding)) {
|
|
if (imports.has(name)) shadowed.add(name);
|
|
if (n.type !== 'VariableDeclarator') constants.delete(name);
|
|
}
|
|
});
|
|
for (const render of r.renders) {
|
|
const identity = origin(r.file, render.name);
|
|
if (identity?.pkg) usedComponents.push(identity);
|
|
for (const key of ['className', 'class']) if (render.attrs.has(key)) {
|
|
const result = classCandidates(render.attrs.get(key), { file: r.file, constants, imports, shadowed }, (context, name) => context.constants.has(name) ? { context, node: context.constants.get(name) } : null);
|
|
collect(result.values, identity?.pkg === '@hm-design/ui' ? identity.name : null);
|
|
uncertain ||= result.unknown;
|
|
}
|
|
}
|
|
walk(r.ast, n => {
|
|
if (n.type === 'JSXSpreadAttribute' || n.type === 'JSXAttribute' && n.name.name === 'dangerouslySetInnerHTML') uncertain = true;
|
|
if (n.type === 'CallExpression') {
|
|
const method = memberName(n.callee);
|
|
if (['setAttribute', 'setAttributeNS', 'insertAdjacentHTML', 'write', 'writeln'].includes(method) || memberName(n.callee?.object) === 'classList') uncertain = true;
|
|
if (/createElement|^(?:_?jsx|_?jsxs|jsxDEV)$/.test(n.callee?.name ?? method ?? '') && n.arguments[1] && (n.arguments[1].type !== 'ObjectExpression' || n.arguments[1].properties.some(p => p.type === 'SpreadElement'))) uncertain = true;
|
|
}
|
|
if (n.type === 'AssignmentExpression' && ['className', 'innerHTML', 'outerHTML'].includes(memberName(n.left))) uncertain = true;
|
|
});
|
|
}
|
|
const implementation = implementationClasses(implementationFiles, parseJS, walk, usedComponents);
|
|
uncertain ||= implementation.incomplete;
|
|
for (const file of entries.filter(f => f.endsWith('.html'))) {
|
|
try {
|
|
const markup = fs.readFileSync(file, 'utf8').replace(/<!--[\s\S]*?-->/g, '').replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, '');
|
|
for (const [, value] of markup.matchAll(/\bclass\s*=\s*["']([^"']*)["']/g)) collect([value]);
|
|
if (/\bclass\s*=\s*[^"'\s]/.test(markup)) uncertain = true;
|
|
} catch { uncertain = true; }
|
|
}
|
|
return {
|
|
component(name) { return componentClasses.get(name) ?? (uncertain && name.startsWith('hm-') ? name.slice(3) : null); },
|
|
evidence(selector) {
|
|
// Restrict the proof to a plain leading positive class and an explicit
|
|
// descendant slot. Commas, pseudos, escapes and nesting stay unpruned.
|
|
const plain = selector.replace(/\[[^\]]*\]/g, '[]');
|
|
const ancestor = !/[,:\\&]/.test(plain) && selector.match(/^\.([A-Za-z_][\w-]*)\s+/)?.[1];
|
|
const explicitSlot = /\[data-slot\s*=\s*(?:"[\w-]+"|'[\w-]+'|[\w-]+)\]/.test(selector);
|
|
const implementationClassPossible = Boolean(ancestor && implementation.classes.has(ancestor));
|
|
const absent = ancestor && explicitSlot && !uncertain && !classes.has(ancestor) && !implementationClassPossible;
|
|
return { status: absent ? 'NOT APPLICABLE' : 'POSSIBLE', requiredAncestorClass: ancestor || null, implementationClassPossible, classInputsComplete: !uncertain, unresolvedImplementationFiles: implementation.unresolvedFiles.map(f => f.replaceAll('\\', '/').split('/packages/').at(-1)), reason: absent ? 'Required positive ancestor class is absent from this complete entry graph, HTML and public implementation class bindings; CSS retained in inventory, not approved' : 'No proven scope exclusion; Component override policy remains enforced' };
|
|
},
|
|
};
|
|
}
|
|
|
|
// Inventory consumer declarations. General layout is not a Component replica.
|
|
export function styleAnalysis({ records, target, postcss, walk, parseJS, selectedFile, knownSlot, origin, add, storybook, entries = [], scopeIncomplete = true, scopeRecords = records, implementationFiles = [] }) {
|
|
const checks = [];
|
|
const scope = classScope(scopeRecords, entries, walk, origin, scopeIncomplete, implementationFiles, parseJS);
|
|
const record = (file, node, selector, component, property, value, important = false, applicability = { status: 'POSSIBLE' }) => {
|
|
const color = rawColor.test(value);
|
|
const spacing = geometry.test(property) && /(?:^|[\s(+])[-+]?(?:\d*\.)?\d+(?:px|rem|em)\b/.test(value) && !/^(?:0(?:px|rem|em)?\s*)+$/.test(value);
|
|
const override = Boolean(component);
|
|
const global = /(?:^|[,\s])(?:html|body|:root|\*)(?:$|[,\s.#:[>])/.test(selector);
|
|
const forbidden = override && applicability.status !== 'NOT APPLICABLE' && (rawColor.test(withoutVariables(value)) || spacing);
|
|
const intent = override || color || spacing || important;
|
|
const ruleId = forbidden ? 'STYLE-001' : 'STYLE-002';
|
|
if (forbidden && !storybook) add('FAIL', ruleId, file, node, 'Hardcoded color / spacing / radius overrides an HM Component; use its documented Token / Prop contract');
|
|
const relative = path.relative(target, file).replaceAll('\\', '/');
|
|
checks.push({ id: `${relative}:${lineOf(node)}:${selector}:${property}:${value}`, file: relative, line: lineOf(node), ruleId, component: component ?? null, selector, property, value, important, tokens: [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map(m => m[1]), scope: global ? 'GLOBAL' : 'COMPONENT_SCOPED', applicability, staticStatus: forbidden && !storybook ? 'FAIL' : 'PASS', runtimeStatus: 'NOT VERIFIED', designIntentStatus: intent ? 'NOT VERIFIED' : 'PASS', reason: intent ? 'Literal styling / Component override requires a documented design decision; computed equality is not approval' : 'No ambiguous override detected; cascade / actual application requires browser evidence' });
|
|
};
|
|
for (const r of records.filter(r => selectedFile(r.file))) {
|
|
if (r.css) {
|
|
try {
|
|
const ast = postcss.parse(fs.readFileSync(r.file, 'utf8'));
|
|
ast.walkDecls(n => {
|
|
const selector = n.parent?.type === 'rule' ? n.parent.selector : `@${n.parent?.name ?? 'declaration'}`;
|
|
const slots = [...selector.matchAll(/data-slot\s*=\s*["']?([\w-]+)/g)].map(m => m[1]);
|
|
const classes = [...selector.matchAll(/\.([A-Za-z_][\w-]*)/g)].map(m => m[1]);
|
|
const component = slots.find(knownSlot) ?? classes.filter(name => name.startsWith('hm-') && knownSlot(name.slice(3))).map(name => scope.component(name)).find(Boolean);
|
|
record(r.file, n, selector, component, n.prop, n.value, n.important, scope.evidence(selector));
|
|
});
|
|
} catch { /* Existing CSS-005 retains parse uncertainty. */ }
|
|
}
|
|
const constants = r.ast ? localConstants(r.ast, walk) : new Map();
|
|
if (r.ast) walk(r.ast, (n, parent) => {
|
|
if (n.type !== 'JSXAttribute' || !['style', 'className'].includes(n.name.name)) return;
|
|
const tag = parent.name?.type === 'JSXMemberExpression' ? `${parent.name.object.name}.${parent.name.property.name}` : parent.name?.name;
|
|
const identity = origin(r.file, tag);
|
|
const component = identity?.pkg === '@hm-design/ui' ? identity.name : null;
|
|
if (n.name.name === 'className') {
|
|
const values = knownStyleStrings(n.value?.expression ?? n.value, constants);
|
|
for (const v of values ?? []) for (const m of v.matchAll(/(?:^|[\s:])([\w-]+)-\[([^\]]+)\]/g)) {
|
|
const property = m[1] === 'gap' ? 'gap' : /^(?:p|m)[xytrbl]?$/.test(m[1]) ? `${m[1][0] === 'p' ? 'padding' : 'margin'}${({ x: '-inline', y: '-block', t: '-top', r: '-right', b: '-bottom', l: '-left' })[m[1][1]] ?? ''}` : m[1] === 'rounded' ? 'border-radius' : 'utility-' + m[1];
|
|
record(r.file, n, `<${tag ?? 'element'}>`, component, property, m[2]);
|
|
}
|
|
return;
|
|
}
|
|
const value = n.value?.expression;
|
|
if (value?.type !== 'ObjectExpression') return;
|
|
for (const p of value.properties) {
|
|
if (p.type !== 'ObjectProperty' || p.computed) continue;
|
|
const key = p.key.name ?? p.key.value;
|
|
const values = knownStyleStrings(p.value, constants);
|
|
const property = String(key).replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
|
|
for (const v of values ?? []) record(r.file, p, `<${tag ?? 'element'}>`, component, property, geometry.test(property) && /^\d+(?:\.\d+)?$/.test(v) ? `${v}px` : v);
|
|
}
|
|
});
|
|
}
|
|
return [...new Map(checks.map(c => [c.id, c])).values()];
|
|
}
|