lint-suite 1.6.2 → 1.6.3

package/stylelint.cjs

@@ -30,12 +30,687 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/lint-suite/src/stylelint.ts
 var stylelint_exports = {};
 __export(stylelint_exports, {
-  stylelint: () => stylelint
+  stylelint: () => stylelint2
 });
 module.exports = __toCommonJS(stylelint_exports);
 var import_stylelint_scss = __toESM(require("stylelint-scss"), 1);
 var import_stylelint_selector_bem_pattern = __toESM(require("stylelint-selector-bem-pattern"), 1);
-var stylelint = {
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/no-unused-classes.ts
+var import_stylelint = __toESM(require("stylelint"), 1);
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/stylesheet-components.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/component-descriptors.ts
+var import_node_fs = require("node:fs");
+
+// packages/lint-suite/src/lib/rules/component-metadata.ts
+var import_typescript = require("typescript");
+var componentArgument = (decorator) => {
+  const { expression } = decorator;
+  if (!(0, import_typescript.isCallExpression)(expression)) return null;
+  if (!(0, import_typescript.isIdentifier)(expression.expression)) return null;
+  const isComponent = expression.expression.text === "Component";
+  if (!isComponent) return null;
+  const [argument] = expression.arguments;
+  if (argument === void 0) return null;
+  if (!(0, import_typescript.isObjectLiteralExpression)(argument)) return null;
+  return argument;
+};
+var decoratedMetadata = (node) => {
+  if (!(0, import_typescript.canHaveDecorators)(node)) return null;
+  const decorators = (0, import_typescript.getDecorators)(node) ?? [];
+  for (const decorator of decorators) {
+    const metadata = componentArgument(decorator);
+    if (metadata !== null) return metadata;
+  }
+  return null;
+};
+var parseComponentMetadata = (text, path) => {
+  const found = [];
+  const visit = (node) => {
+    const metadata = decoratedMetadata(node);
+    if (metadata !== null) found.push(metadata);
+    (0, import_typescript.forEachChild)(node, visit);
+  };
+  const source = (0, import_typescript.createSourceFile)(path, text, import_typescript.ScriptTarget.Latest, true);
+  (0, import_typescript.forEachChild)(source, visit);
+  return found;
+};
+var literalText = (node) => {
+  if (!(0, import_typescript.isStringLiteralLike)(node)) return null;
+  return node.text;
+};
+var literalTexts = (node) => {
+  const single = literalText(node);
+  if (single !== null) return [single];
+  if (!(0, import_typescript.isArrayLiteralExpression)(node)) return [];
+  const texts = [];
+  for (const element of node.elements) {
+    const text = literalText(element);
+    if (text !== null) texts.push(text);
+  }
+  return texts;
+};
+var metadataValue = (metadata, name) => {
+  for (const property of metadata.properties) {
+    if (!(0, import_typescript.isPropertyAssignment)(property)) continue;
+    if (!(0, import_typescript.isIdentifier)(property.name)) continue;
+    const isMatch = property.name.text === name;
+    if (isMatch) return property.initializer;
+  }
+  return null;
+};
+var metadataTexts = (metadata, name) => {
+  const value = metadataValue(metadata, name);
+  if (value === null) return [];
+  return literalTexts(value);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/component-descriptors.ts
+var COMPONENT_MARKER = "@Component";
+var cache = /* @__PURE__ */ new Map();
+var toDescriptor = (metadata) => {
+  const [templateUrl] = metadataTexts(metadata, "templateUrl");
+  const [template] = metadataTexts(metadata, "template");
+  const styleUrls = [
+    ...metadataTexts(metadata, "styleUrl"),
+    ...metadataTexts(metadata, "styleUrls")
+  ];
+  const descriptor = {
+    templateUrl: templateUrl ?? null,
+    template: template ?? null,
+    styleUrls
+  };
+  return descriptor;
+};
+var parseDescriptors = (text, path) => {
+  const hasComponent = text.includes(COMPONENT_MARKER);
+  if (!hasComponent) return [];
+  return parseComponentMetadata(text, path).map(toDescriptor);
+};
+var componentDescriptors = (path) => {
+  try {
+    const stats = (0, import_node_fs.statSync)(path, { bigint: true });
+    const version = `${stats.mtimeNs}:${stats.size}`;
+    const cached = cache.get(path);
+    if (cached?.version === version) return cached.descriptors;
+    const descriptors = parseDescriptors((0, import_node_fs.readFileSync)(path, "utf8"), path);
+    const fresh = { descriptors, version };
+    cache.set(path, fresh);
+    return descriptors;
+  } catch {
+    return [];
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/stylesheet-components.ts
+var MODULE_EXTENSION = /\.ts$/iu;
+var STYLE_EXTENSION = /\.(?:scss|sass|css)$/iu;
+var UNKNOWN_TEMPLATE = { kind: "unknown" };
+var declaredStylesheets = (descriptor, directory) => {
+  const resolveUrl = (url) => (0, import_node_path.resolve)(directory, url);
+  return descriptor.styleUrls.map(resolveUrl);
+};
+var fileTemplate = (descriptor, directory) => {
+  if (descriptor.templateUrl === null) return null;
+  const path = (0, import_node_path.resolve)(directory, descriptor.templateUrl);
+  const isPresent = (0, import_node_fs2.existsSync)(path);
+  if (!isPresent) return null;
+  const source = { kind: "file", path };
+  return source;
+};
+var inlineTemplate = (descriptor, componentPath) => {
+  if (descriptor.template === null) return null;
+  const source = {
+    kind: "inline",
+    source: descriptor.template,
+    path: componentPath
+  };
+  return source;
+};
+var componentTemplate = (descriptor, componentPath) => {
+  const directory = (0, import_node_path.dirname)(componentPath);
+  const file = fileTemplate(descriptor, directory);
+  if (file !== null) return file;
+  const inline = inlineTemplate(descriptor, componentPath);
+  return inline ?? UNKNOWN_TEMPLATE;
+};
+var matchedTemplates = (componentPath, stylesheetPath) => {
+  const directory = (0, import_node_path.dirname)(componentPath);
+  const sources = [];
+  for (const descriptor of componentDescriptors(componentPath)) {
+    const declared = declaredStylesheets(descriptor, directory);
+    const isMatch = declared.includes(stylesheetPath);
+    if (!isMatch) continue;
+    sources.push(componentTemplate(descriptor, componentPath));
+  }
+  return sources;
+};
+var directoryModules = (directory) => {
+  try {
+    return (0, import_node_fs2.readdirSync)(directory).filter((file) => MODULE_EXTENSION.test(file));
+  } catch {
+    return [];
+  }
+};
+var siblingTemplates = (stylesheetPath) => {
+  const path = stylesheetPath.replace(STYLE_EXTENSION, ".html");
+  const isPresent = (0, import_node_fs2.existsSync)(path);
+  if (!isPresent) return [];
+  const source = { kind: "file", path };
+  return [source];
+};
+var stylesheetTemplates = (stylesheetPath) => {
+  const resolved = (0, import_node_path.resolve)(stylesheetPath);
+  const directory = (0, import_node_path.dirname)(resolved);
+  const sources = [];
+  for (const file of directoryModules(directory)) {
+    const componentPath = (0, import_node_path.join)(directory, file);
+    sources.push(...matchedTemplates(componentPath, resolved));
+  }
+  if (sources.length > 0) return sources;
+  return siblingTemplates(resolved);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
+var import_compiler3 = require("@angular/compiler");
+var import_node_fs3 = require("node:fs");
+
+// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
+var import_compiler = require("@angular/compiler");
+
+// packages/lint-suite/src/lib/rules/utils/selector-classes.util.ts
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"), 1);
+var INTERPOLATION_TOKEN = "zzinterpzz";
+var PARENT_TOKEN = "zzparentzz";
+var UNKNOWN_PARENT_SELECTOR = `.${PARENT_TOKEN}`;
+var UNKNOWN_PARTS = new RegExp(
+  `${INTERPOLATION_TOKEN}|${PARENT_TOKEN}`,
+  "gu"
+);
+var INTERPOLATION = /#\{[^}]*\}/gu;
+var DEEP_COMBINATORS = /* @__PURE__ */ new Set(["/deep/", ">>>"]);
+var HOST_PSEUDOS = /* @__PURE__ */ new Set([":host", ":host-context"]);
+var NG_DEEP_PSEUDO = "::ng-deep";
+var REGEXP_META = /[.*+?^${}()|[\]\\]/gu;
+var escapeRegExp = (part) => {
+  return part.replaceAll(REGEXP_META, "\\$&");
+};
+var classNamePattern = (value) => {
+  const literals = value.split(UNKNOWN_PARTS).map(escapeRegExp);
+  const joined = literals.join(".*");
+  return `^${joined}$`;
+};
+var withoutParent = (selector) => {
+  return selector.replaceAll("&", UNKNOWN_PARENT_SELECTOR);
+};
+var withParent = (selector, parent) => {
+  const hasNesting = selector.includes("&");
+  if (hasNesting) return selector.replaceAll("&", parent);
+  return `${parent} ${selector}`;
+};
+var resolveSelectors = (selectors, parents) => {
+  const hasParents = parents.length > 0;
+  if (!hasParents) return selectors.map(withoutParent);
+  const resolved = [];
+  for (const parent of parents) {
+    for (const selector of selectors) {
+      resolved.push(withParent(selector, parent));
+    }
+  }
+  return resolved;
+};
+var isBoundaryNode = (node) => {
+  if (node.type === "combinator") return DEEP_COMBINATORS.has(node.value);
+  if (node.type !== "pseudo") return false;
+  return node.value === NG_DEEP_PSEUDO;
+};
+var addTemplateClass = (value, names) => {
+  const hasInterpolation = value.includes(INTERPOLATION_TOKEN);
+  const hasUnknownParent = value.includes(PARENT_TOKEN);
+  const isDynamic = hasInterpolation || hasUnknownParent;
+  if (isDynamic) return;
+  names.push(value);
+};
+var collectTemplateClasses = (nodes, names) => {
+  for (const node of nodes) {
+    const isBoundary = isBoundaryNode(node);
+    if (isBoundary) return true;
+    if (node.type === "class") {
+      addTemplateClass(node.value, names);
+      continue;
+    }
+    if (node.type !== "pseudo") continue;
+    const isHost = HOST_PSEUDOS.has(node.value);
+    if (isHost) continue;
+    for (const argument of node.nodes) {
+      const isStopped = collectTemplateClasses(argument.nodes, names);
+      if (isStopped) return true;
+    }
+  }
+  return false;
+};
+var selectorTemplateClasses = (selector) => {
+  const names = [];
+  const normalized = selector.replaceAll(INTERPOLATION, INTERPOLATION_TOKEN);
+  try {
+    const root = (0, import_postcss_selector_parser.default)().astSync(normalized);
+    for (const each of root.nodes) collectTemplateClasses(each.nodes, names);
+  } catch {
+    return [];
+  }
+  return [...new Set(names)];
+};
+var classMatcher = (exact, patterns) => {
+  const matches = (name) => {
+    const isExact = exact.has(name);
+    if (isExact) return true;
+    return patterns.some((pattern) => pattern.test(name));
+  };
+  return matches;
+};
+
+// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
+var WHITESPACE = /\s+/u;
+var EXPRESSION_FILE = "class-expression";
+var INTERPOLATION_TOKEN2 = "zzinterpzz";
+var parser = new import_compiler.Parser(new import_compiler.Lexer());
+var spanOf = (source) => {
+  const file = new import_compiler.ParseSourceFile(source, EXPRESSION_FILE);
+  const start = new import_compiler.ParseLocation(file, 0, 0, 0);
+  const span = new import_compiler.ParseSourceSpan(start, start.moveBy(source.length));
+  return span;
+};
+var astOf = (parsed) => {
+  const hasErrors = parsed.errors.length > 0;
+  if (hasErrors) return null;
+  return parsed.ast;
+};
+var parseClassExpression = (source) => {
+  try {
+    const span = spanOf(source);
+    const interpolation = parser.parseInterpolation(source, span, 0, null);
+    if (interpolation) return astOf(interpolation);
+    const binding = parser.parseBinding(source, span, 0);
+    return astOf(binding);
+  } catch {
+    return null;
+  }
+};
+var addNames = (value, names) => {
+  for (const token of value.split(WHITESPACE)) {
+    if (token) names.push(token);
+  }
+};
+var addPrimitive = (ast, names) => {
+  if (typeof ast.value === "string") addNames(ast.value, names);
+};
+var addMapKeys = (ast, names) => {
+  for (const key of ast.keys) {
+    if (key.kind !== "spread") addNames(key.key, names);
+  }
+};
+var addInterpolation = (ast, names) => {
+  for (const text of ast.strings) addNames(text, names);
+};
+var collect = (ast, names) => {
+  if (ast instanceof import_compiler.LiteralPrimitive) {
+    addPrimitive(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.LiteralMap) {
+    addMapKeys(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.Interpolation) {
+    addInterpolation(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.LiteralArray) {
+    for (const expression of ast.expressions) collect(expression, names);
+    return;
+  }
+  if (ast instanceof import_compiler.Conditional) {
+    collect(ast.trueExp, names);
+    collect(ast.falseExp, names);
+  }
+};
+var classExpressionLiterals = (source) => {
+  const ast = parseClassExpression(source);
+  if (ast === null) return [];
+  const names = [];
+  collect(ast, names);
+  return [...new Set(names)];
+};
+var isSpreadKey = (key) => key.kind === "spread";
+var isDynamicAst = (ast) => {
+  if (ast instanceof import_compiler.LiteralPrimitive) return false;
+  if (ast instanceof import_compiler.LiteralMap) return ast.keys.some(isSpreadKey);
+  if (ast instanceof import_compiler.LiteralArray) return ast.expressions.some(isDynamicAst);
+  if (ast instanceof import_compiler.Conditional) {
+    const isTrueDynamic = isDynamicAst(ast.trueExp);
+    const isFalseDynamic = isDynamicAst(ast.falseExp);
+    return isTrueDynamic || isFalseDynamic;
+  }
+  return true;
+};
+var isNamedToken = (token) => token !== INTERPOLATION_TOKEN2;
+var isPatternToken = (token) => {
+  return token.includes(INTERPOLATION_TOKEN2);
+};
+var isPlainToken = (token) => !isPatternToken(token);
+var interpolationUsage = (ast) => {
+  const joined = ast.strings.join(INTERPOLATION_TOKEN2);
+  const tokens = joined.split(WHITESPACE).filter(Boolean);
+  const named = tokens.filter(isNamedToken);
+  const patterns = named.filter(isPatternToken).map(classNamePattern);
+  const names = named.filter(isPlainToken);
+  const usage = {
+    names: [...new Set(names)],
+    patterns: [...new Set(patterns)],
+    isDynamic: named.length < tokens.length
+  };
+  return usage;
+};
+var UNKNOWN_USAGE = {
+  names: [],
+  patterns: [],
+  isDynamic: true
+};
+var classExpressionUsage = (source) => {
+  const ast = parseClassExpression(source);
+  if (ast === null) return UNKNOWN_USAGE;
+  if (ast instanceof import_compiler.Interpolation) return interpolationUsage(ast);
+  const names = [];
+  collect(ast, names);
+  const isDynamic = isDynamicAst(ast);
+  const usage = {
+    names: [...new Set(names)],
+    patterns: [],
+    isDynamic
+  };
+  return usage;
+};
+
+// packages/lint-suite/src/lib/rules/utils/template-classes.util.ts
+var import_compiler2 = require("@angular/compiler");
+var CLASS_ATTRIBUTE = "class";
+var CLASS_BINDING_PREFIX = "class.";
+var TOKEN = /\S+/gu;
+var expressionSource = (value) => {
+  if (!("source" in value)) return null;
+  const { source } = value;
+  if (typeof source !== "string") return null;
+  return source;
+};
+var staticClasses = (attribute) => {
+  const classes = [];
+  const valueSpan = attribute.valueSpan ?? attribute.sourceSpan;
+  for (const token of attribute.value.matchAll(TOKEN)) {
+    const start = valueSpan.start.moveBy(token.index);
+    const end = valueSpan.start.moveBy(token.index + token[0].length);
+    const span = new import_compiler2.ParseSourceSpan(start, end);
+    const templateClass = { name: token[0], span };
+    classes.push(templateClass);
+  }
+  return classes;
+};
+var boundClassName = (input) => {
+  const { details } = input.keySpan;
+  if (details === null) return null;
+  const isClassBinding = details.startsWith(CLASS_BINDING_PREFIX);
+  if (!isClassBinding) return null;
+  return input.name;
+};
+var isClassExpression = (input) => {
+  const isClassName = input.name === CLASS_ATTRIBUTE;
+  if (!isClassName) return false;
+  const { details } = input.keySpan;
+  if (details === null) return true;
+  return details === CLASS_ATTRIBUTE;
+};
+var expressionClasses = (input) => {
+  const source = expressionSource(input.value);
+  if (source === null) return [];
+  const names = classExpressionLiterals(source);
+  const templateClassOf = (name) => {
+    const templateClass = { name, span: input.sourceSpan };
+    return templateClass;
+  };
+  return names.map(templateClassOf);
+};
+var inputClasses = (input) => {
+  const bound = boundClassName(input);
+  if (bound !== null) {
+    const templateClass = { name: bound, span: input.keySpan };
+    return [templateClass];
+  }
+  const isExpression = isClassExpression(input);
+  if (!isExpression) return [];
+  return expressionClasses(input);
+};
+var templateClasses = (node) => {
+  const classes = [];
+  for (const attribute of node.attributes) {
+    const isClassName = attribute.name === CLASS_ATTRIBUTE;
+    if (isClassName) classes.push(...staticClasses(attribute));
+  }
+  for (const input of node.inputs) {
+    classes.push(...inputClasses(input));
+  }
+  return classes;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
+var CLASS_ATTRIBUTE2 = "class";
+var NG_CLASS_ATTRIBUTE = "ngClass";
+var matchesNone = () => false;
+var UNKNOWN_USAGE2 = {
+  has: matchesNone,
+  isDynamic: true,
+  size: 0
+};
+var toRegExp = (pattern) => new RegExp(pattern, "u");
+var expressionSource2 = (value) => {
+  const isWithSource = value instanceof import_compiler3.ASTWithSource;
+  if (!isWithSource) return null;
+  return value.source;
+};
+var isClassInput = (input) => {
+  const isNgClass = input.name === NG_CLASS_ATTRIBUTE;
+  if (isNgClass) return true;
+  const isClass = input.name === CLASS_ATTRIBUTE2;
+  if (!isClass) return false;
+  const { details } = input.keySpan;
+  if (details === null) return true;
+  return details === CLASS_ATTRIBUTE2;
+};
+var ClassUsageVisitor = class extends import_compiler3.TmplAstRecursiveVisitor {
+  names = /* @__PURE__ */ new Set();
+  patterns = /* @__PURE__ */ new Set();
+  isDynamic = false;
+  visitElement(element) {
+    this.collect(element);
+    super.visitElement(element);
+  }
+  visitTemplate(template) {
+    this.collect(template);
+    super.visitTemplate(template);
+  }
+  visitComponent(component) {
+    this.collect(component);
+    super.visitComponent(component);
+  }
+  collect(node) {
+    for (const { name } of templateClasses(node)) this.names.add(name);
+    for (const input of node.inputs) this.collectInput(input);
+  }
+  collectInput(input) {
+    const isClass = isClassInput(input);
+    if (!isClass) return;
+    const source = expressionSource2(input.value);
+    if (source === null) {
+      this.isDynamic = true;
+      return;
+    }
+    const usage = classExpressionUsage(source);
+    for (const name of usage.names) this.names.add(name);
+    for (const pattern of usage.patterns) this.patterns.add(pattern);
+    if (usage.isDynamic) this.isDynamic = true;
+  }
+};
+var templateText = (source) => {
+  if (source.kind === "unknown") return null;
+  if (source.kind === "inline") {
+    const inline = { text: source.source, path: source.path };
+    return inline;
+  }
+  try {
+    const text = (0, import_node_fs3.readFileSync)(source.path, "utf8");
+    const file = { text, path: source.path };
+    return file;
+  } catch {
+    return null;
+  }
+};
+var templateUsage = (sources) => {
+  const visitor = new ClassUsageVisitor();
+  for (const source of sources) {
+    const template = templateText(source);
+    if (template === null) return UNKNOWN_USAGE2;
+    const parsed = (0, import_compiler3.parseTemplate)(template.text, template.path);
+    if (parsed.errors !== null) return UNKNOWN_USAGE2;
+    (0, import_compiler3.tmplAstVisitAll)(visitor, parsed.nodes);
+  }
+  if (visitor.isDynamic) return UNKNOWN_USAGE2;
+  const patterns = [...visitor.patterns].map(toRegExp);
+  const has = classMatcher(visitor.names, patterns);
+  const size = visitor.names.size;
+  const usage = { has, isDynamic: false, size };
+  return usage;
+};
+
+// packages/lint-suite/src/lib/rules/utils/resolved-rules.util.ts
+var walkContainer = (container, parents, visit) => {
+  for (const node of container.nodes ?? []) {
+    if (node.type === "rule") {
+      const resolved = resolveSelectors(node.selectors, parents);
+      visit(node, resolved, parents);
+      walkContainer(node, resolved, visit);
+      continue;
+    }
+    if (node.type !== "atrule") continue;
+    walkContainer(node, parents, visit);
+  }
+};
+var walkResolvedRules = (root, visit) => {
+  walkContainer(root, [], visit);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/no-unused-classes.ts
+var { createPlugin, utils } = import_stylelint.default;
+var DEFAULT_IGNORE_PATTERNS = ["^(js|qa|mat|cdk|mdc)-"];
+var ruleName = "lint-suite/no-unused-classes";
+var rejected = (name) => {
+  return `Unexpected class ".${name}" not used by any template of this stylesheet`;
+};
+var messages = utils.ruleMessages(ruleName, { rejected });
+var meta = {
+  url: "https://github.com/F0rty-Tw0/lint-suite#no-unused-classes"
+};
+var isString = (value) => typeof value === "string";
+var toRegExp2 = (pattern) => new RegExp(pattern, "u");
+var validate = (result, primary, secondary) => {
+  const primaryOptions = { actual: primary, possible: [true] };
+  const possible = { ignoreClassPatterns: [isString] };
+  const secondaryOptions = { actual: secondary, possible, optional: true };
+  return utils.validateOptions(
+    result,
+    ruleName,
+    primaryOptions,
+    secondaryOptions
+  );
+};
+var addNames2 = (selector, names) => {
+  for (const name of selectorTemplateClasses(selector)) names.add(name);
+};
+var extendedClasses = (root) => {
+  const names = /* @__PURE__ */ new Set();
+  const collect2 = (atRule) => addNames2(atRule.params, names);
+  root.walkAtRules("extend", collect2);
+  return names;
+};
+var ruleClasses = (resolved, parents) => {
+  const inherited = /* @__PURE__ */ new Set();
+  for (const parent of parents) addNames2(parent, inherited);
+  const own = /* @__PURE__ */ new Set();
+  for (const selector of resolved) {
+    for (const name of selectorTemplateClasses(selector)) {
+      const isInherited = inherited.has(name);
+      if (isInherited) continue;
+      own.add(name);
+    }
+  }
+  return [...own];
+};
+var reportUnused = (context, rule, name) => {
+  const matchesIgnored = (pattern) => pattern.test(name);
+  const isIgnored = context.ignored.some(matchesIgnored);
+  if (isIgnored) return;
+  const isUsed = context.isUsed(name);
+  if (isUsed) return;
+  const isExtended = context.extended.has(name);
+  if (isExtended) return;
+  const message = messages.rejected(name);
+  const word = `.${name}`;
+  const problem = {
+    ruleName,
+    result: context.result,
+    node: rule,
+    message,
+    word
+  };
+  utils.report(problem);
+};
+var noUnusedClasses = (primary, secondary) => {
+  const walk = (root, result) => {
+    const isValid = validate(result, primary, secondary);
+    if (!isValid) return;
+    const file = root.source?.input.file;
+    if (file === void 0) return;
+    const templates = stylesheetTemplates(file);
+    if (templates.length === 0) return;
+    const usage = templateUsage(templates);
+    if (usage.isDynamic) return;
+    const patterns = secondary?.ignoreClassPatterns ?? DEFAULT_IGNORE_PATTERNS;
+    const ignored = patterns.map(toRegExp2);
+    const extended = extendedClasses(root);
+    const context = {
+      result,
+      ignored,
+      extended,
+      isUsed: usage.has
+    };
+    const visit = (rule, resolved, parents) => {
+      for (const name of ruleClasses(resolved, parents)) {
+        reportUnused(context, rule, name);
+      }
+    };
+    walkResolvedRules(root, visit);
+  };
+  return walk;
+};
+noUnusedClasses.ruleName = ruleName;
+noUnusedClasses.messages = messages;
+noUnusedClasses.meta = meta;
+var plugin = createPlugin(ruleName, noUnusedClasses);
+var no_unused_classes_default = plugin;
+
+// packages/lint-suite/src/stylelint.ts
+var stylelint2 = {
   // Stylelint resolves config for cwd when picking a formatter; without a
   // top-level `rules` an overrides-only config fails with "No rules found".
   rules: {},
@@ -47,7 +722,7 @@ var stylelint = {
         "stylelint-config-standard-scss",
         "stylelint-config-recess-order"
       ],
-      plugins: [...import_stylelint_scss.default, import_stylelint_selector_bem_pattern.default],
+      plugins: [...import_stylelint_scss.default, import_stylelint_selector_bem_pattern.default, no_unused_classes_default],
       rules: {
         "selector-class-pattern": "^(?:(?:o|c|u|t|s|is|has|_|js|qa)-)?[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*(?:__[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)?(?:--[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)?(?:\\[.+\\])?$",
         "plugin/selector-bem-pattern": {
@@ -55,7 +730,8 @@ var stylelint = {
           implicitComponents: ["**/*.component.scss", "**/*.component.css"],
           ignoreCustomProperties: ["^--mdc", "^--sys"]
         },
-        "no-descending-specificity": null
+        "no-descending-specificity": null,
+        "lint-suite/no-unused-classes": true
       }
     }
   ]