lint-suite 2.0.2 → 2.1.0

package/eslint.js

@@ -13,8 +13,8 @@ var definePlugin = (name, rules) => {
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
-import { existsSync } from "node:fs";
-import { dirname as dirname2, resolve } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname3, resolve } from "node:path";
 
 // packages/lint-suite/src/lib/rules/component-metadata.ts
 import {
@@ -34,12 +34,59 @@ import {
 // packages/lint-suite/src/lib/rules/file-cache.ts
 import {
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   renameSync,
   statSync,
   writeFileSync
 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// packages/lint-suite/src/lib/rules/package-version.ts
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "lint-suite";
+var DEV_VERSION = "dev";
+var MAX_MANIFEST_DEPTH = 6;
+var moduleDirectory = () => {
+  const url = import.meta.url;
+  if (typeof url !== "string") return null;
+  return dirname(fileURLToPath(url));
+};
+var manifestVersion = (file) => {
+  const isPresent = existsSync(file);
+  if (!isPresent) return null;
+  try {
+    const manifest = JSON.parse(readFileSync(file, "utf8"));
+    const isRecord = typeof manifest === "object" && manifest !== null;
+    if (!isRecord) return null;
+    if (!("name" in manifest)) return null;
+    if (manifest.name !== PACKAGE_NAME) return null;
+    if (!("version" in manifest)) return null;
+    if (typeof manifest.version !== "string") return null;
+    return manifest.version;
+  } catch {
+    return null;
+  }
+};
+var parentOf = (directory) => {
+  const parent = dirname(directory);
+  if (parent === directory) return null;
+  return parent;
+};
+var packageVersion = () => {
+  let directory = moduleDirectory();
+  for (let depth = 0; depth < MAX_MANIFEST_DEPTH; depth += 1) {
+    if (directory === null) break;
+    const version = manifestVersion(join(directory, "package.json"));
+    if (version !== null) return version;
+    directory = parentOf(directory);
+  }
+  return DEV_VERSION;
+};
+var PACKAGE_VERSION = packageVersion();
+
+// packages/lint-suite/src/lib/rules/file-cache.ts
 var CACHE_FORMAT_VERSION = 1;
 var caches = /* @__PURE__ */ new Set();
 var isFlushRegistered = false;
@@ -48,12 +95,12 @@ var cacheDirectory = () => {
   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");
+  return join2(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`);
+  return join2(directory, `${name}.v${CACHE_FORMAT_VERSION}.json`);
 };
 var isCachedFile = (value) => {
   const isObject = typeof value === "object" && value !== null;
@@ -76,7 +123,7 @@ var load = (cache2) => {
   const file = cacheFile(cache2.name);
   if (file === null) return;
   try {
-    const stored = storedEntries(readFileSync(file, "utf8"));
+    const stored = storedEntries(readFileSync2(file, "utf8"));
     for (const [path, entry] of stored) cache2.entries.set(path, entry);
   } catch {
     return;
@@ -86,7 +133,7 @@ var write = (cache2) => {
   const file = cacheFile(cache2.name);
   if (file === null) return;
   try {
-    mkdirSync(dirname(file), { recursive: true });
+    mkdirSync(dirname2(file), { recursive: true });
     const temporary = `${file}.${process.pid}.tmp`;
     const stored = Object.fromEntries(cache2.entries);
     writeFileSync(temporary, JSON.stringify(stored));
@@ -122,10 +169,10 @@ var readCached = (cache2, path, parse2) => {
   if (!cache2.loaded) load(cache2);
   try {
     const stats = statSync(path, { bigint: true });
-    const version = `${stats.mtimeNs}:${stats.size}`;
+    const version = `${PACKAGE_VERSION}:${stats.mtimeNs}:${stats.size}`;
     const cached = cache2.entries.get(path);
     if (cached?.version === version) return cached.value;
-    const value = parse2(readFileSync(path, "utf8"), path);
+    const value = parse2(readFileSync2(path, "utf8"), path);
     const fresh = { value, version };
     cache2.entries.set(path, fresh);
     cache2.dirty = true;
@@ -231,7 +278,7 @@ var matchesTemplate = (metadata, directory, templateFilename) => {
 };
 var templateMetadata = (componentPath, templateFilename) => {
   const components = componentMetadata(componentPath);
-  const directory = dirname2(componentPath);
+  const directory = dirname3(componentPath);
   const matches = (metadata) => {
     return matchesTemplate(metadata, directory, templateFilename);
   };
@@ -246,7 +293,7 @@ var stylesheetFiles = (paths, directory) => {
   const sources = [];
   for (const path of paths) {
     const resolved = resolve(directory, path);
-    const isPresent = existsSync(resolved);
+    const isPresent = existsSync2(resolved);
     if (!isPresent) continue;
     const source = { kind: "file", path: resolved };
     sources.push(source);
@@ -267,7 +314,7 @@ var inlineSources = (styles, componentPath) => {
 var metadataSources = (componentPath, templateFilename) => {
   const metadata = templateMetadata(componentPath, templateFilename);
   if (metadata === null) return [];
-  const directory = dirname2(componentPath);
+  const directory = dirname3(componentPath);
   const files = stylesheetFiles(metadata.styleUrls, directory);
   const inline = inlineSources(metadata.styles, componentPath);
   return [...files, ...inline];
@@ -276,7 +323,7 @@ var siblingSources = (templateFilename) => {
   const base2 = templateFilename.replace(HTML_EXTENSION, "");
   const candidateOf = (extension) => `${base2}${extension}`;
   const candidates = SIBLING_EXTENSIONS.map(candidateOf);
-  return stylesheetFiles(candidates, dirname2(templateFilename));
+  return stylesheetFiles(candidates, dirname3(templateFilename));
 };
 var componentStylesheets = (templateFilename) => {
   const componentPath = templateFilename.replace(HTML_EXTENSION, ".ts");
@@ -286,7 +333,7 @@ var componentStylesheets = (templateFilename) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/linked-stylesheets.ts
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 
 // packages/lint-suite/src/lib/rules/utils/template-links.util.ts
 var LINK_TAG = /<link\b[^>]*>/giu;
@@ -309,16 +356,16 @@ var linkedStylesheetHrefs = (template) => {
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/linked-stylesheets.ts
 var linkedStylesheets = (template, templateFilename) => {
   const hrefs = linkedStylesheetHrefs(template);
-  return stylesheetFiles(hrefs, dirname3(templateFilename));
+  return stylesheetFiles(hrefs, dirname4(templateFilename));
 };
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 import { parse } from "postcss-scss";
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-imports.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { basename, dirname as dirname4, join as join2, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { basename, dirname as dirname5, join as join3, resolve as resolve2 } from "node:path";
 var QUOTED = /'([^']*)'|"([^"]*)"/u;
 var SKIPPED_PREFIXES = ["sass:", "http", "url("];
 var specifierOf = (params) => {
@@ -335,25 +382,28 @@ var isResolvable = (specifier) => {
   if (isSkipped) return false;
   return !specifier.endsWith(".css");
 };
+var importSpecifier = (params) => {
+  const specifier = specifierOf(params);
+  if (specifier === null) return null;
+  const isCandidate = isResolvable(specifier);
+  if (!isCandidate) return null;
+  return specifier;
+};
 var candidatesOf = (path) => {
   const isStylesheet = path.endsWith(".scss");
-  if (isStylesheet) return [path, join2(dirname4(path), `_${basename(path)}`)];
-  const partial = join2(dirname4(path), `_${basename(path)}.scss`);
+  if (isStylesheet) return [path, join3(dirname5(path), `_${basename(path)}`)];
+  const partial = join3(dirname5(path), `_${basename(path)}.scss`);
   return [
     `${path}.scss`,
     partial,
-    join2(path, "index.scss"),
-    join2(path, "_index.scss")
+    join3(path, "index.scss"),
+    join3(path, "_index.scss")
   ];
 };
-var resolveStylesheetImport = (params, directory) => {
-  const specifier = specifierOf(params);
-  if (specifier === null) return null;
-  const isCandidate = isResolvable(specifier);
-  if (!isCandidate) return null;
+var resolveStylesheetImport = (specifier, directory) => {
   const path = resolve2(directory, specifier);
   const candidates = candidatesOf(path);
-  const existing = candidates.find((candidate) => existsSync2(candidate));
+  const existing = candidates.find((candidate) => existsSync3(candidate));
   return existing ?? null;
 };
 
@@ -456,19 +506,19 @@ var addSelectors = (selectors, entry) => {
     entry.patterns.push(...patterns);
   }
 };
-var addImport = (node, entry, directory) => {
+var addImport = (node, entry) => {
   const isImport = IMPORT_AT_RULES.has(node.name);
   if (!isImport) return;
-  const imported = resolveStylesheetImport(node.params, directory);
-  if (imported !== null) entry.imports.push(imported);
+  const specifier = importSpecifier(node.params);
+  if (specifier !== null) entry.imports.push(specifier);
 };
-var collectStylesheet = (root, directory) => {
+var collectStylesheet = (root) => {
   const entry = { classes: [], patterns: [], imports: [] };
   const onRule = (_rule, resolved) => {
     addSelectors(resolved, entry);
   };
   const onAtRule = (node) => {
-    addImport(node, entry, directory);
+    addImport(node, entry);
   };
   walkResolvedRules(root, onRule);
   root.walkAtRules(onAtRule);
@@ -485,8 +535,7 @@ var inlineStylesheets = /* @__PURE__ */ new Map();
 var merged = /* @__PURE__ */ new Map();
 var parseStylesheet = (source, path) => {
   try {
-    const root = parse(source, { from: path });
-    return collectStylesheet(root, dirname5(path));
+    return collectStylesheet(parse(source, { from: path }));
   } catch {
     return EMPTY_ENTRY;
   }
@@ -502,14 +551,16 @@ var inlineEntry = (source, path) => {
   inlineStylesheets.set(key2, entry);
   return entry;
 };
-var collectImports = (entry, chain, visited) => {
-  for (const imported of entry.imports) {
+var collectImports = (entry, directory, chain, visited) => {
+  for (const specifier of entry.imports) {
+    const imported = resolveStylesheetImport(specifier, directory);
+    if (imported === null) continue;
     const isVisited = visited.has(imported);
     if (isVisited) continue;
     visited.add(imported);
     const importedEntry = fileEntry(imported);
     chain.push(importedEntry);
-    collectImports(importedEntry, chain, visited);
+    collectImports(importedEntry, dirname6(imported), chain, visited);
   }
 };
 var entryOf = (source) => {
@@ -524,7 +575,7 @@ var collectChain = (source, chain, visited) => {
   }
   const entry = entryOf(source);
   chain.push(entry);
-  collectImports(entry, chain, visited);
+  collectImports(entry, dirname6(source.path), chain, visited);
 };
 var mergeChain = (chain) => {
   const exact = /* @__PURE__ */ new Set();
@@ -1182,7 +1233,7 @@ var methodCandidate = (node, localPrivateOnly, implementedMethods) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
-import { dirname as dirname6, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, resolve as resolve3 } from "node:path";
 import { TSESTree as TSESTree5 } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-literals.ts
@@ -1226,7 +1277,7 @@ import {
   R3TargetBinder,
   parseTemplate
 } from "@angular/compiler";
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
 import {
@@ -1325,7 +1376,7 @@ var externalTemplateReads = (filename) => {
     const version = `${stats.mtimeNs}:${stats.size}`;
     const cached = externalTemplates.get(filename);
     if (cached?.version === version) return cached.reads;
-    const reads = templateReads(readFileSync2(filename, "utf8"), filename);
+    const reads = templateReads(readFileSync3(filename, "utf8"), filename);
     externalTemplates.set(filename, { reads, version });
     return reads;
   } catch {
@@ -1393,7 +1444,7 @@ var inlineTemplateReads = (template, reads, filename) => {
 var externalTemplatePropertyReads = (templateUrl, reads, filename) => {
   if (!templateUrl) return true;
   const url = text(templateUrl);
-  return url !== null && addReads(reads, externalTemplateReads(resolve3(dirname6(filename), url)));
+  return url !== null && addReads(reads, externalTemplateReads(resolve3(dirname7(filename), url)));
 };
 var componentTemplateReads = (metadata, reads, filename) => {
   const template = metadataValue2(metadata, "template");
@@ -1622,7 +1673,7 @@ var lexicalThisVisitor = (thisStack) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-write-targets.ts
 import { TSESTree as TSESTree8 } from "@typescript-eslint/utils";
-var parentOf = (node) => {
+var parentOf2 = (node) => {
   if (node.type === TSESTree8.AST_NODE_TYPES.Program) return void 0;
   return node.parent;
 };
@@ -1666,10 +1717,10 @@ var isWrapping = (parent, child) => {
 };
 var isDirectWrite = (node) => {
   let current = node;
-  let parent = parentOf(node);
+  let parent = parentOf2(node);
   while (parent && isTypeScriptExpressionWrapper(parent) && parent.expression === current) {
     current = parent;
-    parent = parentOf(parent);
+    parent = parentOf2(parent);
   }
   const isDeleteExpression2 = parent?.type === TSESTree8.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
   const isAssignment = isSimpleAssignmentTarget(parent, current);
@@ -1677,7 +1728,7 @@ var isDirectWrite = (node) => {
 };
 var isDestructuringOrLoopTarget = (node) => {
   let current = node;
-  let parent = parentOf(node);
+  let parent = parentOf2(node);
   let patternTarget = false;
   while (parent) {
     const wrapper = isWrapping(parent, current);
@@ -1687,7 +1738,7 @@ var isDestructuringOrLoopTarget = (node) => {
       patternTarget = true;
     }
     current = parent;
-    parent = parentOf(parent);
+    parent = parentOf2(parent);
   }
   const isSimpleTarget = isSimpleAssignmentTarget(parent, current);
   const isAssignedPattern = patternTarget && isSimpleTarget;
@@ -1870,11 +1921,11 @@ var replaceDeclarations = (index, previous, next) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-reconciliation.ts
-import { dirname as dirname9, normalize as normalize2 } from "node:path";
+import { dirname as dirname10, normalize as normalize2 } from "node:path";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
-import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import { dirname as dirname7, normalize } from "node:path";
+import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { dirname as dirname8, normalize } from "node:path";
 import { isIdentifier as isIdentifier3, isStringLiteralLike as isStringLiteralLike3 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
@@ -2313,6 +2364,7 @@ var addTemplateReads = ({
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
+var MISSING = -1n;
 var memberNameOf2 = (member) => {
   const name = member.name;
   if (!name) return [];
@@ -2338,17 +2390,27 @@ var addTemplateMentions = (source, sink) => {
   for (const [name] of source.matchAll(IDENTIFIER)) sink.addMention(name);
 };
 var templateFileVersion = (fileName) => {
-  const { mtimeNs, size } = statSync3(fileName, { bigint: true });
-  const directory = dirname7(normalize(fileName));
-  const version = { directory, fileName, mtimeNs, size };
-  return version;
+  const directory = dirname8(normalize(fileName));
+  try {
+    const { mtimeNs, size } = statSync3(fileName, { bigint: true });
+    const version = { directory, fileName, mtimeNs, size };
+    return version;
+  } catch {
+    const missing = {
+      directory,
+      fileName,
+      mtimeNs: MISSING,
+      size: MISSING
+    };
+    return missing;
+  }
 };
 var templateFileIsCurrent = (version) => {
   try {
     const current = statSync3(version.fileName, { bigint: true });
     return current.mtimeNs === version.mtimeNs && current.size === version.size;
   } catch {
-    return false;
+    return version.mtimeNs === MISSING;
   }
 };
 var templateSourceOf = (angularClass2, allNames, sink, versions) => {
@@ -2367,9 +2429,9 @@ var templateSourceOf = (angularClass2, allNames, sink, versions) => {
     return inlineSource;
   }
   const templateFileName = template.fileName;
+  versions.push(templateFileVersion(templateFileName));
   try {
-    versions.push(templateFileVersion(templateFileName));
-    const source = readFileSync3(templateFileName, "utf8");
+    const source = readFileSync4(templateFileName, "utf8");
     const externalSource = {
       fileName: templateFileName,
       source
@@ -2417,6 +2479,18 @@ var collectAngularTemplateReads = ({
   return templateReads2;
 };
 
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-dangling-imports.ts
+import { isImportDeclaration } from "typescript";
+var hasDanglingImport = (sourceFile, checker) => {
+  for (const statement of sourceFile.statements) {
+    if (!isImportDeclaration(statement)) continue;
+    if (!statement.importClause) continue;
+    const symbol = checker.getSymbolAtLocation(statement.moduleSpecifier);
+    if (!symbol) return true;
+  }
+  return false;
+};
+
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
 import {
   forEachChild as forEachChild2,
@@ -2974,6 +3048,13 @@ var collectFileReads = (index, sourceFile, checker, sink) => {
     return noTemplateReads;
   }
 };
+var addDanglingFallback = (index, sourceFile, mentionedNames, sink) => {
+  const isCandidate = (name) => index.candidateNames.has(name);
+  const mentioned = [...mentionedNames];
+  const names = mentioned.filter(isCandidate);
+  const reason = `${sourceFile.fileName}: an import resolves to no module`;
+  sink.addFallbackNames(names, reason);
+};
 var computeEntry = (index, sourceFile, checker) => {
   const declarations = /* @__PURE__ */ new Set();
   const dependencies = /* @__PURE__ */ new Set();
@@ -2998,9 +3079,12 @@ var computeEntry = (index, sourceFile, checker) => {
     }
   };
   const reads = collectFileReads(index, sourceFile, checker, sink);
+  const dangling = hasDanglingImport(sourceFile, checker);
+  if (dangling) addDanglingFallback(index, sourceFile, mentionedNames, sink);
   dependencies.delete(sourceFile);
   const fileEntry2 = {
     ...reads,
+    dangling,
     declarations,
     dependencies,
     fallbackNames,
@@ -3035,7 +3119,7 @@ import {
   canHaveDecorators as canHaveDecorators2,
   getDecorators as getDecorators2,
   isCallExpression as isCallExpression2,
-  isImportDeclaration,
+  isImportDeclaration as isImportDeclaration2,
   isStringLiteralLike as isStringLiteralLike5
 } from "typescript";
 var decoratorKinds = [
@@ -3051,16 +3135,16 @@ var isAngularCoreFile = (declaration) => {
   const fileName = declaration.getSourceFile().fileName.replaceAll("\\", "/");
   return fileName.includes("/node_modules/@angular/core/");
 };
-var parentOf2 = (node) => {
+var parentOf3 = (node) => {
   return node.parent;
 };
 var importedFromAngularCore = (declaration) => {
-  let current = parentOf2(declaration);
+  let current = parentOf3(declaration);
   while (current) {
-    if (isImportDeclaration(current)) {
+    if (isImportDeclaration2(current)) {
       return isStringLiteralLike5(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
     }
-    current = parentOf2(current);
+    current = parentOf3(current);
   }
   return false;
 };
@@ -3108,7 +3192,7 @@ var classDecoratorKind = (declaration, discovery) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-metadata-values.ts
-import { dirname as dirname8, resolve as resolve4 } from "node:path";
+import { dirname as dirname9, resolve as resolve4 } from "node:path";
 import {
   isIdentifier as isIdentifier6,
   isNumericLiteral as isNumericLiteral2,
@@ -3158,7 +3242,7 @@ var templateOf = (metadata, fileName, discovery) => {
   if (url) {
     const text2 = stringValue(url, discovery);
     if (text2 === null) return void 0;
-    const externalFileName = resolve4(dirname8(fileName), text2);
+    const externalFileName = resolve4(dirname9(fileName), text2);
     const externalTemplate = {
       fileName: externalFileName,
       kind: "external"
@@ -3541,6 +3625,7 @@ var lazyChecker = (program) => {
   let typeChecker;
   return () => typeChecker ??= program.getTypeChecker();
 };
+var isDangling = (entry) => entry.dangling;
 var indexMissingEntries = (index, sourceFiles, checker) => {
   for (const sourceFile of sourceFiles) {
     const isEntryIndexed = index.entries.has(sourceFile.fileName);
@@ -3552,6 +3637,7 @@ var reindexProgram = (index, program, checker) => {
   const indexable = indexableSourceFiles(program);
   const current = currentSourceFiles(program);
   dropReplacedEntries(index, current);
+  dropEntries(index, isDangling);
   const newNames = reconcileClasses(index, indexable, current, checker);
   dropEntriesMentioning(index, newNames);
   index.program = program;
@@ -3576,7 +3662,7 @@ var isLocalEntry = (entry, sourceFile, directory) => {
 var refreshLocalEntries = (index, program, fileName, checker) => {
   const sourceFile = program.getSourceFile(fileName);
   if (!sourceFile) return;
-  const directory = dirname9(normalize2(sourceFile.fileName));
+  const directory = dirname10(normalize2(sourceFile.fileName));
   const stale = [];
   for (const entry of index.entries.values()) {
     if (entry.templateVersions.length === 0) continue;
@@ -5765,7 +5851,24 @@ var ruleDefaults4 = { entryPoints: [...entryPointDefaults] };
 var defaultOptions7 = [ruleDefaults4];
 
 // packages/lint-suite/src/lib/rules/no-unused-exports/export-index.ts
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname11 } from "node:path";
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/disk-resolver.ts
+import { resolveModuleName, sys } from "typescript";
+var diskResolver = (program) => {
+  const options = program.getCompilerOptions();
+  return (specifier) => {
+    const containingFile = specifier.getSourceFile().fileName;
+    const { resolvedModule } = resolveModuleName(
+      specifier.text,
+      containingFile,
+      options,
+      sys
+    );
+    if (!resolvedModule) return void 0;
+    return program.getSourceFile(resolvedModule.resolvedFileName);
+  };
+};
 
 // packages/lint-suite/src/lib/rules/no-unused-exports/utils/export-usage.util.ts
 var MAX_DEPTH = 50;
@@ -5996,7 +6099,7 @@ import {
   isCallExpression as isCallExpression4,
   isExportAssignment,
   isExportDeclaration,
-  isImportDeclaration as isImportDeclaration2,
+  isImportDeclaration as isImportDeclaration3,
   isModuleDeclaration,
   isNamespaceImport
 } from "typescript";
@@ -6088,22 +6191,37 @@ var exportedNames = (statement) => {
   return [name];
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-target.util.ts
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-resolver.util.ts
+import { isStringLiteralLike as isStringLiteralLike9 } from "typescript";
 var declarationOf = (specifier, checker) => {
   const symbol = checker.getSymbolAtLocation(specifier);
   if (!symbol) return void 0;
   return symbol.valueDeclaration ?? symbol.declarations?.[0];
 };
-var moduleTarget = (specifier, checker, isExternal) => {
-  if (!specifier) return void 0;
+var declaredSourceFile = (specifier, checker) => {
   const declaration = declarationOf(specifier, checker);
   if (!declaration) return void 0;
-  const sourceFile = declaration.getSourceFile();
+  return declaration.getSourceFile();
+};
+var moduleTarget = (sourceFile, isExternal) => {
   if (sourceFile.isDeclarationFile) return void 0;
   const isSourceExternal = isExternal(sourceFile);
   if (isSourceExternal) return void 0;
   return sourceFile.fileName;
 };
+var moduleResolver = (resolution, dangling) => {
+  const { checker, isExternal, onDisk } = resolution;
+  return (specifier) => {
+    if (!specifier) return void 0;
+    const declared = declaredSourceFile(specifier, checker);
+    if (declared) return moduleTarget(declared, isExternal);
+    if (!isStringLiteralLike9(specifier)) return void 0;
+    const found = onDisk(specifier);
+    if (found) return moduleTarget(found, isExternal);
+    dangling.push(specifier.text);
+    return void 0;
+  };
+};
 
 // packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-edges.util.ts
 var importNames = (clause) => {
@@ -6169,16 +6287,17 @@ var emptyEdges = () => {
     declared: /* @__PURE__ */ new Set(),
     imports: [],
     reExports: [],
-    starTargets: []
+    starTargets: [],
+    dangling: []
   };
   return edges;
 };
-var moduleEdges = (sourceFile, checker, isExternal) => {
-  const resolve5 = (specifier) => moduleTarget(specifier, checker, isExternal);
+var moduleEdges = (sourceFile, resolution) => {
   const edges = emptyEdges();
+  const resolve5 = moduleResolver(resolution, edges.dangling);
   let skipped = false;
   for (const statement of sourceFile.statements) {
-    if (isImportDeclaration2(statement)) {
+    if (isImportDeclaration3(statement)) {
       addImport2(statement, edges, resolve5);
     } else if (isExportDeclaration(statement)) {
       if (statement.moduleSpecifier) addExportFrom(statement, edges, resolve5);
@@ -6223,28 +6342,32 @@ var LAST_AGGREGATE = /* @__PURE__ */ new Map();
 var projectKey = (program) => {
   const configFilePath = program.getCompilerOptions()["configFilePath"];
   if (typeof configFilePath === "string") return configFilePath;
-  const directories = program.getRootFileNames().map(dirname10);
+  const directories = program.getRootFileNames().map(dirname11);
   const uniqueDirectorySet = new Set(directories);
   const uniqueDirectories = [...uniqueDirectorySet];
   const sortedDirectories = uniqueDirectories.sort();
   return sortedDirectories.join("|");
 };
-var fileEdges = (sourceFile, checker, isExternal) => {
+var fileEdges = (sourceFile, resolution) => {
   const cached = FILE_EDGES.get(sourceFile);
-  if (cached) return cached;
-  const edges = moduleEdges(sourceFile, checker, isExternal);
+  const isCached = cached !== void 0;
+  const isSettled = isCached && cached.dangling.length === 0;
+  if (isSettled) return cached;
+  const edges = moduleEdges(sourceFile, resolution);
   FILE_EDGES.set(sourceFile, edges);
   return edges;
 };
 var programEdges = (program) => {
   const checker = program.getTypeChecker();
   const isExternal = (sourceFile) => program.isSourceFileFromExternalLibrary(sourceFile);
+  const onDisk = diskResolver(program);
+  const resolution = { checker, isExternal, onDisk };
   const byFile = /* @__PURE__ */ new Map();
   for (const sourceFile of program.getSourceFiles()) {
     if (sourceFile.isDeclarationFile) continue;
     const isSourceExternal = isExternal(sourceFile);
     if (isSourceExternal) continue;
-    byFile.set(sourceFile.fileName, fileEdges(sourceFile, checker, isExternal));
+    byFile.set(sourceFile.fileName, fileEdges(sourceFile, resolution));
   }
   return byFile;
 };