lint-suite 1.6.3 → 2.0.0

package/stylelint.js

@@ -6,11 +6,205 @@ import bemPattern from "stylelint-selector-bem-pattern";
 import stylelint from "stylelint";
 
 // packages/lint-suite/src/lib/rules/no-unused-classes/styles/stylesheet-components.ts
-import { existsSync, readdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 
-// packages/lint-suite/src/lib/rules/no-unused-classes/styles/component-descriptors.ts
-import { readFileSync, statSync } from "node:fs";
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/linked-templates.ts
+import { readdirSync } from "node:fs";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
+
+// packages/lint-suite/src/lib/rules/file-cache.ts
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+var CACHE_FORMAT_VERSION = 1;
+var caches = /* @__PURE__ */ new Set();
+var isFlushRegistered = false;
+var cacheDirectory = () => {
+  const { LINT_SUITE_CACHE, LINT_SUITE_CACHE_DIR } = process.env;
+  const isDisabled = LINT_SUITE_CACHE === "0";
+  if (isDisabled) return null;
+  if (LINT_SUITE_CACHE_DIR) return LINT_SUITE_CACHE_DIR;
+  return join(process.cwd(), "node_modules", ".cache", "lint-suite");
+};
+var cacheFile = (name) => {
+  const directory = cacheDirectory();
+  if (directory === null) return null;
+  return join(directory, `${name}.v${CACHE_FORMAT_VERSION}.json`);
+};
+var isCachedFile = (value) => {
+  const isObject = typeof value === "object" && value !== null;
+  if (!isObject) return false;
+  const hasVersion = "version" in value && typeof value.version === "string";
+  return hasVersion && "value" in value;
+};
+var storedEntries = (text) => {
+  const entries = /* @__PURE__ */ new Map();
+  const parsed = JSON.parse(text);
+  const isRecord = typeof parsed === "object" && parsed !== null;
+  if (!isRecord) return entries;
+  for (const [path, entry] of Object.entries(parsed)) {
+    if (isCachedFile(entry)) entries.set(path, entry);
+  }
+  return entries;
+};
+var load = (cache2) => {
+  cache2.loaded = true;
+  const file = cacheFile(cache2.name);
+  if (file === null) return;
+  try {
+    const stored = storedEntries(readFileSync(file, "utf8"));
+    for (const [path, entry] of stored) cache2.entries.set(path, entry);
+  } catch {
+    return;
+  }
+};
+var write = (cache2) => {
+  const file = cacheFile(cache2.name);
+  if (file === null) return;
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    const stored = Object.fromEntries(cache2.entries);
+    writeFileSync(temporary, JSON.stringify(stored));
+    renameSync(temporary, file);
+  } catch {
+    return;
+  }
+};
+var flushFileCaches = () => {
+  for (const cache2 of caches) {
+    if (!cache2.dirty) continue;
+    write(cache2);
+    cache2.dirty = false;
+  }
+};
+var registerFlush = () => {
+  if (isFlushRegistered) return;
+  isFlushRegistered = true;
+  process.once("exit", flushFileCaches);
+};
+var createFileCache = (name) => {
+  const cache2 = {
+    name,
+    entries: /* @__PURE__ */ new Map(),
+    loaded: false,
+    dirty: false
+  };
+  caches.add(cache2);
+  registerFlush();
+  return cache2;
+};
+var readCached = (cache2, path, parse) => {
+  if (!cache2.loaded) load(cache2);
+  try {
+    const stats = statSync(path, { bigint: true });
+    const version = `${stats.mtimeNs}:${stats.size}`;
+    const cached = cache2.entries.get(path);
+    if (cached?.version === version) return cached.value;
+    const value = parse(readFileSync(path, "utf8"), path);
+    const fresh = { value, version };
+    cache2.entries.set(path, fresh);
+    cache2.dirty = true;
+    return value;
+  } catch {
+    return null;
+  }
+};
+
+// packages/lint-suite/src/lib/rules/utils/template-links.util.ts
+var LINK_TAG = /<link\b[^>]*>/giu;
+var STYLESHEET_REL = /\brel\s*=\s*["']stylesheet["']/iu;
+var HREF = /\bhref\s*=\s*["']([^"']*)["']/iu;
+var UNRESOLVABLE = /^(?:\/|[^:/?#]+:)/u;
+var hrefOf = (tag) => {
+  const isStylesheet = STYLESHEET_REL.test(tag);
+  if (!isStylesheet) return null;
+  const href = HREF.exec(tag)?.[1] ?? "";
+  const isUnresolvable = UNRESOLVABLE.test(href);
+  const isLocal = href.length > 0 && !isUnresolvable;
+  return isLocal ? href : null;
+};
+var linkedStylesheetHrefs = (template) => {
+  const tags = template.match(LINK_TAG) ?? [];
+  return tags.map(hrefOf).filter((href) => href !== null);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-classes/styles/linked-templates.ts
+var TEMPLATE_EXTENSION = /\.html$/iu;
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+var links = createFileCache("template-links");
+var linkIndex = null;
+var templateLinks = (templatePath) => {
+  return readCached(links, templatePath, linkedStylesheetHrefs) ?? [];
+};
+var isWalkable = (name) => {
+  const isDotfile = name.startsWith(".");
+  if (isDotfile) return false;
+  return !SKIPPED_DIRECTORIES.has(name);
+};
+var walkTemplates = (root) => {
+  const found = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (directory === void 0) break;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const path = join2(directory, entry.name);
+      const isDirectory = entry.isDirectory();
+      if (isDirectory) {
+        const canWalk = isWalkable(entry.name);
+        if (canWalk) pending.push(path);
+        continue;
+      }
+      const isTemplate = TEMPLATE_EXTENSION.test(entry.name);
+      if (isTemplate) found.push(path);
+    }
+  }
+  return found;
+};
+var templatesUnder = (root) => {
+  try {
+    return walkTemplates(root);
+  } catch {
+    return [];
+  }
+};
+var templatesByStylesheet = (root) => {
+  const byStylesheet = /* @__PURE__ */ new Map();
+  for (const template of templatesUnder(root)) {
+    const directory = dirname2(template);
+    for (const href of templateLinks(template)) {
+      const stylesheet = resolve(directory, href);
+      const linked = byStylesheet.get(stylesheet) ?? [];
+      linked.push(template);
+      byStylesheet.set(stylesheet, linked);
+    }
+  }
+  return byStylesheet;
+};
+var currentLinkIndex = () => {
+  const now = performance.now();
+  const cached = linkIndex;
+  const isFresh = cached !== null && now - cached.builtAt < cached.buildDuration * 100;
+  if (isFresh) return cached;
+  const templates2 = templatesByStylesheet(process.cwd());
+  const fresh = {
+    builtAt: now,
+    buildDuration: performance.now() - now,
+    templates: templates2
+  };
+  linkIndex = fresh;
+  return fresh;
+};
+var linkedTemplates = (stylesheetPath) => {
+  return currentLinkIndex().templates.get(stylesheetPath) ?? [];
+};
 
 // packages/lint-suite/src/lib/rules/component-metadata.ts
 import {
@@ -26,6 +220,8 @@ import {
   isPropertyAssignment,
   isStringLiteralLike
 } from "typescript";
+var COMPONENT_MARKER = "@Component";
+var cache = createFileCache("component-metadata");
 var componentArgument = (decorator) => {
   const { expression } = decorator;
   if (!isCallExpression(expression)) return null;
@@ -46,17 +242,6 @@ var decoratedMetadata = (node) => {
   }
   return null;
 };
-var parseComponentMetadata = (text, path) => {
-  const found = [];
-  const visit = (node) => {
-    const metadata = decoratedMetadata(node);
-    if (metadata !== null) found.push(metadata);
-    forEachChild(node, visit);
-  };
-  const source = createSourceFile(path, text, ScriptTarget.Latest, true);
-  forEachChild(source, visit);
-  return found;
-};
 var literalText = (node) => {
   if (!isStringLiteralLike(node)) return null;
   return node.text;
@@ -86,55 +271,60 @@ var metadataTexts = (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 styleUrl = metadataTexts(metadata, "styleUrl");
+  const listedStyleUrls = metadataTexts(metadata, "styleUrls");
+  const styleUrls = [...styleUrl, ...listedStyleUrls];
+  const styles = metadataTexts(metadata, "styles");
   const descriptor = {
     templateUrl: templateUrl ?? null,
     template: template ?? null,
-    styleUrls
+    styleUrls,
+    styles
   };
   return descriptor;
 };
-var parseDescriptors = (text, path) => {
+var parseComponentMetadata = (text, path) => {
+  const found = [];
   const hasComponent = text.includes(COMPONENT_MARKER);
-  if (!hasComponent) return [];
-  return parseComponentMetadata(text, path).map(toDescriptor);
+  if (!hasComponent) return found;
+  const visit = (node) => {
+    const metadata = decoratedMetadata(node);
+    if (metadata !== null) found.push(toDescriptor(metadata));
+    forEachChild(node, visit);
+  };
+  const source = createSourceFile(path, text, ScriptTarget.Latest, true);
+  forEachChild(source, visit);
+  return found;
 };
-var componentDescriptors = (path) => {
-  try {
-    const stats = 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(readFileSync(path, "utf8"), path);
-    const fresh = { descriptors, version };
-    cache.set(path, fresh);
-    return descriptors;
-  } catch {
-    return [];
-  }
+var componentMetadata = (path) => {
+  return readCached(cache, path, parseComponentMetadata) ?? [];
 };
 
 // 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 listings = /* @__PURE__ */ new Map();
+var directoryListing = (directory) => {
+  const stats = statSync2(directory, { bigint: true });
+  const version = `${stats.mtimeNs}`;
+  const cached = listings.get(directory);
+  if (cached?.version === version) return cached.files;
+  const files = readdirSync2(directory);
+  const fresh = { files, version };
+  listings.set(directory, fresh);
+  return files;
+};
 var declaredStylesheets = (descriptor, directory) => {
-  const resolveUrl = (url) => resolve(directory, url);
+  const resolveUrl = (url) => resolve2(directory, url);
   return descriptor.styleUrls.map(resolveUrl);
 };
 var fileTemplate = (descriptor, directory) => {
   if (descriptor.templateUrl === null) return null;
-  const path = resolve(directory, descriptor.templateUrl);
+  const path = resolve2(directory, descriptor.templateUrl);
   const isPresent = existsSync(path);
   if (!isPresent) return null;
   const source = { kind: "file", path };
@@ -150,16 +340,16 @@ var inlineTemplate = (descriptor, componentPath) => {
   return source;
 };
 var componentTemplate = (descriptor, componentPath) => {
-  const directory = dirname(componentPath);
+  const directory = dirname3(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 = dirname(componentPath);
+  const directory = dirname3(componentPath);
   const sources = [];
-  for (const descriptor of componentDescriptors(componentPath)) {
+  for (const descriptor of componentMetadata(componentPath)) {
     const declared = declaredStylesheets(descriptor, directory);
     const isMatch = declared.includes(stylesheetPath);
     if (!isMatch) continue;
@@ -167,30 +357,37 @@ var matchedTemplates = (componentPath, stylesheetPath) => {
   }
   return sources;
 };
-var directoryModules = (directory) => {
+var directoryFiles = (directory, extension) => {
   try {
-    return readdirSync(directory).filter((file) => MODULE_EXTENSION.test(file));
+    return directoryListing(directory).filter((file) => extension.test(file));
   } catch {
     return [];
   }
 };
-var siblingTemplates = (stylesheetPath) => {
-  const path = stylesheetPath.replace(STYLE_EXTENSION, ".html");
-  const isPresent = existsSync(path);
-  if (!isPresent) return [];
-  const source = { kind: "file", path };
-  return [source];
+var fallbackTemplates = (stylesheetPath) => {
+  const sibling = stylesheetPath.replace(STYLE_EXTENSION, ".html");
+  const paths = /* @__PURE__ */ new Set();
+  const hasSibling = existsSync(sibling);
+  if (hasSibling) paths.add(sibling);
+  for (const path of linkedTemplates(stylesheetPath)) paths.add(path);
+  const toSource = (path) => {
+    const source = { kind: "file", path };
+    return source;
+  };
+  const pathList = [...paths];
+  return pathList.map(toSource);
 };
 var stylesheetTemplates = (stylesheetPath) => {
-  const resolved = resolve(stylesheetPath);
-  const directory = dirname(resolved);
+  const resolved = resolve2(stylesheetPath);
+  const directory = dirname3(resolved);
   const sources = [];
-  for (const file of directoryModules(directory)) {
-    const componentPath = join(directory, file);
-    sources.push(...matchedTemplates(componentPath, resolved));
+  for (const file of directoryFiles(directory, MODULE_EXTENSION)) {
+    const componentPath = join3(directory, file);
+    const matched = matchedTemplates(componentPath, resolved);
+    sources.push(...matched);
   }
   if (sources.length > 0) return sources;
-  return siblingTemplates(resolved);
+  return fallbackTemplates(resolved);
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
@@ -200,23 +397,8 @@ import {
   parseTemplate,
   tmplAstVisitAll
 } from "@angular/compiler";
-import { readFileSync as readFileSync2 } from "node:fs";
 
-// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
-import {
-  Conditional,
-  Interpolation,
-  Lexer,
-  LiteralArray,
-  LiteralMap,
-  LiteralPrimitive,
-  ParseLocation,
-  ParseSourceFile,
-  ParseSourceSpan,
-  Parser
-} from "@angular/compiler";
-
-// packages/lint-suite/src/lib/rules/utils/selector-classes.util.ts
+// packages/lint-suite/src/lib/rules/selector-classes.ts
 import selectorParser from "postcss-selector-parser";
 var INTERPOLATION_TOKEN = "zzinterpzz";
 var PARENT_TOKEN = "zzparentzz";
@@ -296,7 +478,8 @@ var selectorTemplateClasses = (selector) => {
   } catch {
     return [];
   }
-  return [...new Set(names)];
+  const uniqueNames = new Set(names);
+  return [...uniqueNames];
 };
 var classMatcher = (exact, patterns) => {
   const matches = (name) => {
@@ -308,6 +491,18 @@ var classMatcher = (exact, patterns) => {
 };
 
 // packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
+import {
+  Conditional,
+  Interpolation,
+  Lexer,
+  LiteralArray,
+  LiteralMap,
+  LiteralPrimitive,
+  ParseLocation,
+  ParseSourceFile,
+  ParseSourceSpan,
+  Parser
+} from "@angular/compiler";
 var WHITESPACE = /\s+/u;
 var EXPRESSION_FILE = "class-expression";
 var INTERPOLATION_TOKEN2 = "zzinterpzz";
@@ -377,7 +572,8 @@ var classExpressionLiterals = (source) => {
   if (ast === null) return [];
   const names = [];
   collect(ast, names);
-  return [...new Set(names)];
+  const uniqueNames = new Set(names);
+  return [...uniqueNames];
 };
 var isSpreadKey = (key) => key.kind === "spread";
 var isDynamicAst = (ast) => {
@@ -402,9 +598,11 @@ var interpolationUsage = (ast) => {
   const named = tokens.filter(isNamedToken);
   const patterns = named.filter(isPatternToken).map(classNamePattern);
   const names = named.filter(isPlainToken);
+  const uniqueNames = new Set(names);
+  const uniquePatterns = new Set(patterns);
   const usage = {
-    names: [...new Set(names)],
-    patterns: [...new Set(patterns)],
+    names: [...uniqueNames],
+    patterns: [...uniquePatterns],
     isDynamic: named.length < tokens.length
   };
   return usage;
@@ -421,8 +619,9 @@ var classExpressionUsage = (source) => {
   const names = [];
   collect(ast, names);
   const isDynamic = isDynamicAst(ast);
+  const uniqueNames = new Set(names);
   const usage = {
-    names: [...new Set(names)],
+    names: [...uniqueNames],
     patterns: [],
     isDynamic
   };
@@ -490,14 +689,21 @@ var templateClasses = (node) => {
   const classes = [];
   for (const attribute of node.attributes) {
     const isClassName = attribute.name === CLASS_ATTRIBUTE;
-    if (isClassName) classes.push(...staticClasses(attribute));
+    if (isClassName) {
+      const found = staticClasses(attribute);
+      classes.push(...found);
+    }
   }
   for (const input of node.inputs) {
-    classes.push(...inputClasses(input));
+    const found = inputClasses(input);
+    classes.push(...found);
   }
   return classes;
 };
 
+// packages/lint-suite/src/lib/rules/utils/to-regexp.util.ts
+var toRegExp = (pattern) => new RegExp(pattern, "u");
+
 // packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
 var CLASS_ATTRIBUTE2 = "class";
 var NG_CLASS_ATTRIBUTE = "ngClass";
@@ -507,7 +713,7 @@ var UNKNOWN_USAGE2 = {
   isDynamic: true,
   size: 0
 };
-var toRegExp = (pattern) => new RegExp(pattern, "u");
+var templates = createFileCache("template-usage");
 var expressionSource2 = (value) => {
   const isWithSource = value instanceof ASTWithSource;
   if (!isWithSource) return null;
@@ -556,33 +762,35 @@ var ClassUsageVisitor = class extends TmplAstRecursiveVisitor {
     if (usage.isDynamic) this.isDynamic = true;
   }
 };
-var templateText = (source) => {
+var parseUsage = (text, path) => {
+  const parsed = parseTemplate(text, path);
+  if (parsed.errors !== null) return null;
+  const visitor = new ClassUsageVisitor();
+  tmplAstVisitAll(visitor, parsed.nodes);
+  const names = [...visitor.names];
+  const patterns = [...visitor.patterns];
+  const entry = { names, patterns, isDynamic: visitor.isDynamic };
+  return entry;
+};
+var sourceUsage = (source) => {
   if (source.kind === "unknown") return null;
-  if (source.kind === "inline") {
-    const inline = { text: source.source, path: source.path };
-    return inline;
-  }
-  try {
-    const text = readFileSync2(source.path, "utf8");
-    const file = { text, path: source.path };
-    return file;
-  } catch {
-    return null;
-  }
+  if (source.kind === "inline") return parseUsage(source.source, source.path);
+  return readCached(templates, source.path, parseUsage) ?? null;
 };
 var templateUsage = (sources) => {
-  const visitor = new ClassUsageVisitor();
+  const names = /* @__PURE__ */ new Set();
+  const patterns = /* @__PURE__ */ new Set();
   for (const source of sources) {
-    const template = templateText(source);
-    if (template === null) return UNKNOWN_USAGE2;
-    const parsed = parseTemplate(template.text, template.path);
-    if (parsed.errors !== null) return UNKNOWN_USAGE2;
-    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 entry = sourceUsage(source);
+    if (entry === null) return UNKNOWN_USAGE2;
+    if (entry.isDynamic) return UNKNOWN_USAGE2;
+    for (const name of entry.names) names.add(name);
+    for (const pattern of entry.patterns) patterns.add(pattern);
+  }
+  const patternList = [...patterns];
+  const compiled = patternList.map(toRegExp);
+  const has = classMatcher(names, compiled);
+  const size = names.size;
   const usage = { has, isDynamic: false, size };
   return usage;
 };
@@ -616,7 +824,6 @@ 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] };
@@ -675,12 +882,12 @@ var noUnusedClasses = (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);
+    const templates2 = stylesheetTemplates(file);
+    if (templates2.length === 0) return;
+    const usage = templateUsage(templates2);
     if (usage.isDynamic) return;
     const patterns = secondary?.ignoreClassPatterns ?? DEFAULT_IGNORE_PATTERNS;
-    const ignored = patterns.map(toRegExp2);
+    const ignored = patterns.map(toRegExp);
     const extended = extendedClasses(root);
     const context = {
       result,
@@ -725,6 +932,9 @@ var stylelint2 = {
           ignoreCustomProperties: ["^--mdc", "^--sys"]
         },
         "no-descending-specificity": null,
+        // A stylesheet class no linked template uses is reported.
+        // Bad: .ghost {} used by no template
+        // Good: delete it, or use it in a template
         "lint-suite/no-unused-classes": true
       }
     }