knip 6.40.0 → 6.42.0

package/README.md

@@ -48,7 +48,7 @@ following projects:
 
 [1]: https://www.npmx.dev/package/knip
 [2]: https://img.shields.io/npm/v/knip?color=f56e0f
-[3]: https://img.shields.io/npm/dm/knip?color=f56e0f
+[3]: https://img.shields.io/badge/dynamic/json?url=https://npm-gapless.webpro.nl/downloads/range/last-month/knip&query=$.totalCompact&label=downloads&suffix=/month&color=f56e0f
 [4]: https://github.com/webpro-nl/knip
 [5]:
   https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f

package/dist/ConfigurationChief.d.ts

@@ -237,6 +237,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'expo-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'expressive-code'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -247,6 +252,16 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'filesystem-routing'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        flue?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         fumadocs?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -712,6 +727,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'solidjs-vite-plugin'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sst?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -827,6 +847,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsrs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         tsup?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1076,8 +1101,11 @@ export declare class ConfigurationChief {
         eve?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "expo-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "filesystem-routing"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        flue?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1171,6 +1199,7 @@ export declare class ConfigurationChief {
         "serverless-framework"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "simple-git-hooks"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "size-limit"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "solidjs-vite-plugin"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         sst?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         starlight?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         stencil?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1194,6 +1223,7 @@ export declare class ConfigurationChief {
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsd?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        tsrs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         turbo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -40,6 +40,7 @@ export declare class DependencyDeputy {
         peerDependencies: DependencySet;
         optionalPeerDependencies: DependencySet;
         requiredPeerDependencies: DependencyArray;
+        uninstalledOptionalDependencies: DependencySet;
         allDependencies: DependencySet;
         engines: Record<string, string>;
         isPrivate: boolean;

package/dist/DependencyDeputy.js

@@ -38,15 +38,25 @@ export class DependencyDeputy {
         const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        const packageNames = [...dependencies, ...peerDependencies, ...(this.isProduction ? [] : devDependencies)];
+        const uninstalledOptionalDependencies = new Set();
+        const packageNames = [
+            ...dependencies,
+            ...peerDependencies,
+            ...optionalDependencies,
+            ...(this.isProduction ? [] : devDependencies),
+        ];
         if (this.isReportDependencies) {
-            const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
+            const { hostDependencies, installedBinaries, hasTypesIncluded, uninstalledDependencies } = getDependencyMetaData({
                 packageNames,
                 dir,
             });
             this.setHostDependencies(name, hostDependencies);
             this.installedBinaries.set(name, installedBinaries);
             this.hasTypesIncluded.set(name, hasTypesIncluded);
+            for (const dependency of optionalDependencies) {
+                if (uninstalledDependencies.has(dependency))
+                    uninstalledOptionalDependencies.add(dependency);
+            }
         }
         const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
         const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
@@ -66,6 +76,7 @@ export class DependencyDeputy {
             peerDependencies: new Set(peerDependencies),
             optionalPeerDependencies,
             requiredPeerDependencies,
+            uninstalledOptionalDependencies,
             allDependencies: new Set(allDependencies),
             engines: manifest.engines ?? {},
             isPrivate: Boolean(manifest.private),
@@ -171,6 +182,21 @@ export class DependencyDeputy {
                 }
             }
         }
+        const optionalDependencies = new Set();
+        for (const name of workspaceNames) {
+            const manifest = this._manifests.get(name);
+            if (!manifest)
+                continue;
+            for (const dependency of manifest.uninstalledOptionalDependencies) {
+                const defaultBinaryName = dependency.replace(/^@[^/]+\//, '');
+                if (defaultBinaryName === binaryName) {
+                    optionalDependencies.add(dependency);
+                    this.addReferencedDependency(name, dependency);
+                }
+            }
+        }
+        if (optionalDependencies.size)
+            return optionalDependencies;
         return;
     }
     isInDependencies(workspaceName, packageName, isDevOnly) {

package/dist/IssueCollector.js

@@ -1,7 +1,6 @@
 import picomatch from 'picomatch';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { partition } from './util/array.js';
-import { prependDirToPattern } from './util/glob.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
 import { relative } from './util/path.js';
 const createMatcher = (patterns) => {
@@ -82,23 +81,22 @@ export class IssueCollector {
             return;
         const issueTypePatterns = new Map();
         for (const [pattern, issueTypes] of Object.entries(ignoreIssues)) {
-            const id = prependDirToPattern(this.cwd, pattern);
             for (const issueType of issueTypes) {
                 if (!issueTypePatterns.has(issueType)) {
                     issueTypePatterns.set(issueType, []);
                 }
-                issueTypePatterns.get(issueType)?.push(id);
+                issueTypePatterns.get(issueType)?.push(pattern);
             }
         }
         for (const [issueType, patterns] of issueTypePatterns) {
             this.issueMatchers.set(issueType, picomatch(patterns, { dot: true }));
         }
     }
-    shouldIgnoreIssue(filePath, issueType) {
+    shouldIgnoreIssue(relativePath, issueType) {
         const matcher = this.issueMatchers.get(issueType);
         if (!matcher)
             return false;
-        return matcher(filePath);
+        return matcher(relativePath);
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -110,17 +108,17 @@ export class IssueCollector {
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
-            if (this.isMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnorePatterns);
+            const symbol = relative(this.cwd, filePath);
+            if (this.isMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnorePatterns);
                 continue;
             }
-            if (this.isFileMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnoreFilesPatterns);
+            if (this.isFileMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnoreFilesPatterns);
                 continue;
             }
-            if (this.shouldIgnoreIssue(filePath, 'files'))
+            if (this.shouldIgnoreIssue(symbol, 'files'))
                 continue;
-            const symbol = relative(this.cwd, filePath);
             this.issues.files[symbol] = {
                 [symbol]: { type: 'files', filePath, symbol, workspace: '', severity: this.rules.files, fixes: [] },
             };
@@ -131,15 +129,15 @@ export class IssueCollector {
     addIssue(issue) {
         if (!this.workspaceFilter(issue.filePath))
             return;
-        if (this.isMatch(issue.filePath)) {
-            this.markUsedPatterns(issue.filePath, this.unusedIgnorePatterns);
+        const key = relative(this.cwd, issue.filePath);
+        if (this.isMatch(key)) {
+            this.markUsedPatterns(key, this.unusedIgnorePatterns);
             return;
         }
-        if (this.shouldIgnoreIssue(issue.filePath, issue.type))
+        if (this.shouldIgnoreIssue(key, issue.type))
             return;
         if (this.rules[issue.type] === 'off')
             return;
-        const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
         const issues = this.issues[issue.type];
         issues[key] = issues[key] ?? {};

package/dist/IssueFixer.js

@@ -21,7 +21,7 @@ export const fix = async (issues, counters, options) => {
     }
     if (options.isFormat) {
         const report = await formatly(Array.from(touchedFiles));
-        if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+        if (report.ran && report.result.runner !== 'dry-run' && report.result.code === 0) {
             debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
         }
         else {

package/dist/WorkspaceWorker.js

@@ -14,7 +14,7 @@ import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './uti
 import { isCatalog, isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { filterTransitiveDependencies } from './util/filter-transitive-dependencies.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, join, toRelative } from './util/path.js';
+import { basename, dirname, join, relative, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
 import { formatCauseMessage } from './util/errors.js';
 import { logError } from './util/log.js';
@@ -294,6 +294,7 @@ export class WorkspaceWorker {
             }
             const options = {
                 ...baseScriptOptions,
+                pluginName,
                 config,
                 configFilePath: containingFilePath,
                 configFileDir: cwd,
@@ -469,18 +470,24 @@ export class WorkspaceWorker {
             hints.push({ type: `${type}-empty`, identifier, workspaceName });
             return hints;
         }
+        const dir = this.dir;
+        const relativePaths = [];
+        const hasMatch = (isMatch) => {
+            for (let i = 0; i < filePaths.length; i++) {
+                if (isMatch((relativePaths[i] ??= relative(dir, filePaths[i]))))
+                    return true;
+            }
+            return false;
+        };
         for (const pattern of patterns) {
             if (pattern.startsWith('!'))
                 continue;
-            const filePathOrPattern = join(this.dir, pattern.replace(/!$/, ''));
-            if (includedPaths.has(filePathOrPattern)) {
+            const id = pattern.replace(/!$/, '');
+            if (includedPaths.has(join(dir, id))) {
                 hints.push({ type: `${type}-redundant`, identifier: pattern, workspaceName });
             }
-            else {
-                const matcher = picomatch(filePathOrPattern);
-                if (!filePaths.some(filePath => matcher(filePath))) {
-                    hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
-                }
+            else if (!hasMatch(picomatch(id))) {
+                hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
             }
         }
         if (type === 'project' && compilerExtensions) {

package/dist/binaries/bash-parser.js

@@ -1,26 +1,11 @@
-import { parse } from 'unbash';
+import { forEachChild, parse } from 'unbash';
 import { debugLogObject } from '../util/debug.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { substringBefore, truncate } from '../util/string.js';
-import { walkCommands } from '../util/scripts.js';
+import { isScriptExpansion } from '../util/scripts.js';
 import { getDependenciesFromCommand } from './command.js';
 import { toScript } from './util.js';
-const collectExpansionScripts = (word, out) => {
-    if (!word.parts)
-        return;
-    for (const part of word.parts) {
-        if ((part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') && part.script) {
-            out.push(part.script);
-        }
-        else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
-            for (const child of part.parts) {
-                if (child.type === 'CommandExpansion' && child.script)
-                    out.push(child.script);
-            }
-        }
-    }
-};
 export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
@@ -51,23 +36,21 @@ export const getDependenciesFromScript = (script, options) => {
     };
     const processScript = (s) => {
         collectFunctionNames(s.commands);
-        const pending = [];
-        const mainDeps = [];
-        for (const statement of s.commands) {
-            for (const command of walkCommands(statement.command))
-                mainDeps.push(...processCommand(command, pending));
-        }
-        const expansionDeps = pending.flatMap(inner => processScript(inner));
-        return [...mainDeps, ...expansionDeps];
+        const inputs = [];
+        const visit = (node) => {
+            if (node.type === 'Command')
+                inputs.push(...processCommand(node));
+            if (isScriptExpansion(node)) {
+                if (node.script)
+                    inputs.push(...processScript(node.script));
+            }
+            else
+                forEachChild(node, visit);
+        };
+        visit(s);
+        return inputs;
     };
-    const processCommand = (node, pending) => {
-        if (node.name)
-            collectExpansionScripts(node.name, pending);
-        for (const prefix of node.prefix)
-            if (prefix.value)
-                collectExpansionScripts(prefix.value, pending);
-        for (const suffix of node.suffix)
-            collectExpansionScripts(suffix, pending);
+    const processCommand = (node) => {
         if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
         return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);

package/dist/binaries/command.d.ts

@@ -2,4 +2,4 @@ import type { Command, Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
 import { type Input } from '../util/input.ts';
 export declare const getInputsFromNodeOptions: (prefix: Command['prefix']) => Input[];
-export declare const getDependenciesFromCommand: (node: Command, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];
+export declare const getDependenciesFromCommand: (node: Pick<Command, 'name' | 'prefix' | 'args'>, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];

package/dist/binaries/command.js

@@ -1,17 +1,23 @@
 import { Plugins, pluginArgsMap } from '../plugins.js';
 import { toDeferResolve } from '../util/input.js';
 import { extractBinary, isInNodeModulesBin, isRelativeNodeModulesBin } from '../util/modules.js';
+import { getCommandWords } from '../util/scripts.js';
 import { resolve as fallbackResolve, spawningBinaries } from './fallback.js';
 import KnownResolvers, { isPackageManager } from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
 import { parseNodeArgs, toCommandBinary } from './util.js';
-export const getInputsFromNodeOptions = (prefix) => prefix
-    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-    .map(a => a.value.value)
-    .map(arg => parseNodeArgs(arg.split(' ')))
-    .filter(args => args.require)
-    .flatMap(arg => arg.require)
-    .map(id => toDeferResolve(id));
+export const getInputsFromNodeOptions = (prefix) => {
+    const inputs = [];
+    for (const item of prefix) {
+        if (item.type !== 'Assignment' || item.name !== 'NODE_OPTIONS' || item.value.type !== 'Word')
+            continue;
+        const args = parseNodeArgs(item.value.value.split(' '));
+        if (args.require)
+            for (const id of [args.require].flat())
+                inputs.push(toDeferResolve(id));
+    }
+    return inputs;
+};
 export const getDependenciesFromCommand = (node, options, fromWords = options.fromArgs) => {
     const text = node.name?.value;
     if (!text)
@@ -31,7 +37,7 @@ export const getDependenciesFromCommand = (node, options, fromWords = options.fr
         };
     }
     const { fromArgs } = options;
-    const words = node.suffix;
+    const words = getCommandWords(node);
     if (binary === '!' || binary === 'test')
         return fromArgs(words);
     const fromNodeOptions = getInputsFromNodeOptions(node.prefix);

package/dist/binaries/resolvers/bun.js

@@ -10,6 +10,7 @@ const commands = new Set([
     'auth',
     'build',
     'c',
+    'check',
     'ci',
     'cloud',
     'completions',

package/dist/graph/build.js

@@ -51,8 +51,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
     }
     deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
-    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
-    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
+    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: id, id })));
+    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: id, id })));
     if (options.configFilePath) {
         principal.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
     }
@@ -79,7 +79,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         const dependencies = deputy.getDependencies(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath, options.isUseTscFiles);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
             name,
@@ -122,7 +122,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 inputs.add(toProductionEntry(tryRealpath(id), { containingFilePath: tsConfigFilePath }));
         }
         const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
-        const fn = (id) => ({ pattern: prependDir(options.cwd, prependDir(name, id)), id, workspaceName: name });
+        const fn = (id) => ({ pattern: prependDir(name, id), id, workspaceName: name });
         collector.addIgnorePatterns(config.ignore.map(fn));
         collector.addIgnoreFilesPatterns(config.ignoreFiles.map(fn));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
@@ -249,7 +249,10 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
         const developmentMatchers = [];
         if (options.isProduction) {
-            const toPattern = (pattern) => join(isAbsolute(pattern) ? '' : dir, removeProductionSuffix(pattern));
+            const toPattern = (pattern) => {
+                const id = removeProductionSuffix(pattern);
+                return isAbsolute(id) ? relative(options.cwd, id) : join(name, id);
+            };
             for (const map of [entryPatterns, entryPatternsSkipExports]) {
                 for (const patterns of map.values()) {
                     const [excluded, included] = partition(patterns, pattern => pattern.startsWith('!'));
@@ -260,7 +263,12 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 }
             }
         }
-        const productionPaths = (paths) => developmentMatchers.length ? paths.filter(path => !developmentMatchers.some(match => match(path))) : paths;
+        const productionPaths = (paths) => developmentMatchers.length
+            ? paths.filter(path => {
+                const relativePath = relative(options.cwd, path);
+                return !developmentMatchers.some(match => match(relativePath));
+            })
+            : paths;
         const userEntryPatterns = options.isProduction
             ? worker.getProductionEntryFilePatterns()
             : worker.getEntryFilePatterns();
@@ -313,10 +321,11 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             }
             if (extensions.length > 0) {
                 const extPart = extensions.length === 1 ? extensions[0] : `.{${extensions.map(ext => ext.slice(1)).join(',')}}`;
-                const bases = include ? new Set(include.map(p => picomatch.scan(p).base || dir)) : new Set([dir]);
+                const tsConfigDir = relative(dir, dirname(tsConfigFilePath));
+                const bases = include ? new Set(include.map(p => join(tsConfigDir, picomatch.scan(p).base))) : new Set(['']);
                 const patterns = [
-                    ...Array.from(bases, base => `${base}/**/*${extPart}`),
-                    ...(exclude?.map(p => `!${p}`) ?? []),
+                    ...Array.from(bases, base => join(base, `**/*${extPart}`)),
+                    ...(exclude?.map(p => `!${join(tsConfigDir, p)}`) ?? []),
                 ];
                 const compilerPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'compiler extension paths' });
                 for (const compilerPath of compilerPaths) {

package/dist/graph-explorer/operations/is-referenced.js

@@ -38,10 +38,16 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
             return hasCompleteResult();
         }
         const node = graph.get(path);
-        const file = node?.importedBy;
-        if (!identifier || !node || !file) {
+        if (!identifier || !node) {
             return false;
         }
+        if (isEntryFile && node.skipExports) {
+            isReferenced = true;
+            return hasCompleteResult();
+        }
+        const file = node.importedBy;
+        if (!file)
+            return false;
         const follow = (sources, nextId, nextViaStar = viaStar) => {
             for (const byFilePath of sources) {
                 if (walkDown(byFilePath, nextId, nextViaStar))

package/dist/manifest/index.d.ts

@@ -7,6 +7,7 @@ declare const getMetaDataFromPackageJson: ({ dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
+    uninstalledDependencies: Set<string>;
 };
 export declare const getDependencyMetaData: typeof getMetaDataFromPackageJson;
 export {};

package/dist/manifest/index.js

@@ -5,6 +5,7 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     const hostDependencies = new Map();
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
+    const uninstalledDependencies = new Set();
     const addBinary = (key, value) => {
         const set = installedBinaries.get(key);
         if (set)
@@ -15,10 +16,9 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     for (const packageName of packageNames) {
         const manifest = loadPackageManifest({ dir, packageName });
         if (manifest) {
-            const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
-            const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});
+            const binaries = typeof manifest.bin === 'string' ? [packageName] : Object.keys(manifest.bin ?? {});
             for (const binaryName of binaries)
-                addBinary(binaryName, packageName);
+                addBinary(binaryName.replace(/^@[^/]+\//, ''), packageName);
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {
@@ -35,11 +35,15 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
             if (!isDefinitelyTyped(packageName) && (manifest.types || manifest.typings))
                 hasTypesIncluded.add(packageName);
         }
+        else {
+            uninstalledDependencies.add(packageName);
+        }
     }
     return {
         hostDependencies,
         installedBinaries,
         hasTypesIncluded,
+        uninstalledDependencies,
     };
 };
 export const getDependencyMetaData = timerify(getMetaDataFromPackageJson);

package/dist/plugins/_component-style-urls/component-style-urls-visitor.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../types/config.ts';
+export declare function createComponentStyleUrlsVisitor(ctx: PluginVisitorContext, isSpecifier: (specifier: string) => boolean): PluginVisitorObject;

package/dist/plugins/_component-style-urls/component-style-urls-visitor.js

@@ -0,0 +1,40 @@
+import { IMPORT_FLAGS } from '../../constants.js';
+import { getPropertyValues } from '../../typescript/ast-helpers.js';
+import { dirname, join } from '../../util/path.js';
+export function createComponentStyleUrlsVisitor(ctx, isSpecifier) {
+    const componentNames = new Set();
+    return {
+        Program() {
+            componentNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!isSpecifier(node.source?.value))
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportSpecifier' &&
+                    spec.imported.type === 'Identifier' &&
+                    spec.imported.name === 'Component')
+                    componentNames.add(spec.local.name);
+            }
+        },
+        ClassDeclaration(node) {
+            if (componentNames.size === 0)
+                return;
+            const dir = dirname(ctx.filePath);
+            for (const decorator of node.decorators ?? []) {
+                const expr = decorator.expression;
+                if (expr?.type !== 'CallExpression')
+                    continue;
+                if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
+                    continue;
+                const arg = expr.arguments?.[0];
+                if (arg?.type !== 'ObjectExpression')
+                    continue;
+                for (const url of getPropertyValues(arg, 'styleUrl'))
+                    ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+                for (const url of getPropertyValues(arg, 'styleUrls'))
+                    ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+            }
+        },
+    };
+}

package/dist/plugins/angular/index.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { createComponentStyleUrlsVisitor } from '../_component-style-urls/component-style-urls-visitor.js';
 import * as karma from '../karma/helpers.js';
 const title = 'Angular';
 const enablers = ['@angular/cli'];
@@ -72,7 +73,7 @@ const resolveConfig = async (config, options) => {
                     karma.inputsFromFrameworks(['jasmine']).forEach(inputs.add, inputs);
                 }
                 if (karmaConfig && !karma.configFiles.includes(karmaConfig)) {
-                    inputs.add(toConfig('karma', karmaConfig, { containingFilePath: options.configFilePath }));
+                    inputs.add(toConfig('karma', karmaConfig));
                 }
             }
         }
@@ -111,11 +112,16 @@ const isAngularBuilderRefWithName = ({ builderRef, name }) => {
 };
 const PRODUCTION_CONFIG_NAME = 'production';
 const BUILD_TARGET_NAME = 'build';
+const isAngularSpecifier = (specifier) => specifier === '@angular/core';
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createComponentStyleUrlsVisitor(ctx, isAngularSpecifier));
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    registerVisitors,
 };
 export default plugin;