knip 2.25.2 → 2.26.0

package/README.md

@@ -244,6 +244,7 @@ This is especially useful over time when such configuration files change (and th
 
 Knip contains a growing list of plugins:
 
+- [Angular][plugin-angular]
 - [Ava][plugin-ava]
 - [Babel][plugin-babel]
 - [Capacitor][plugin-capacitor]
@@ -662,6 +663,7 @@ Knip takes the following JSDoc/TSDoc tags into account:
       --include-entry-exports  Include entry files when reporting unused exports
       -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)
       --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated
+      --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)
       --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)
       --reporter-options       Pass extra options to the reporter (as JSON string, see example)
       --no-config-hints        Suppress configuration hints
@@ -863,6 +865,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [71]: https://www.joshuakgoldberg.com/blog/speeding-up-centered-part-4-unused-code-bloat/
 [72]: https://github.com/webpro/knip/graphs/contributors
 [73]: https://contrib.rocks/image?repo=webpro/knip
+[plugin-angular]: ./src/plugins/angular
 [plugin-ava]: ./src/plugins/ava
 [plugin-babel]: ./src/plugins/babel
 [plugin-capacitor]: ./src/plugins/capacitor

package/dist/ConfigurationChief.d.ts

@@ -8,7 +8,7 @@ type ConfigurationManagerOptions = {
 };
 export type Workspace = {
     name: string;
-    pkgName?: string;
+    pkgName: string;
     dir: string;
     ancestors: string[];
     config: WorkspaceConfiguration;

package/dist/ConfigurationChief.js

@@ -15,7 +15,7 @@ import { _dirGlob } from './util/glob.js';
 import { _load } from './util/loader.js';
 import { getKeysByValue } from './util/object.js';
 import { join, relative, toPosix } from './util/path.js';
-import { toCamelCase } from './util/plugin.js';
+import { normalizePluginConfig, toCamelCase } from './util/plugin.js';
 import { byPathDepth } from './util/workspace.js';
 const { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, } = parsedArgValues;
 const workspaceArg = rawWorkspaceArg ? toPosix(rawWorkspaceArg).replace(/^\.\//, '').replace(/\/$/, '') : undefined;
@@ -116,6 +116,13 @@ export class ConfigurationChief {
         const { syncCompilers, asyncCompilers } = rawLocalConfig;
         const extensions = [...Object.keys(syncCompilers ?? {}), ...Object.keys(asyncCompilers ?? {})];
         const defaultWorkspaceConfig = getDefaultWorkspaceConfig(extensions);
+        const rootPluginConfigs = {};
+        for (const [name, pluginConfig] of Object.entries(rawLocalConfig)) {
+            const pluginName = toCamelCase(name);
+            if (PLUGIN_NAMES.includes(pluginName)) {
+                rootPluginConfigs[pluginName] = normalizePluginConfig(pluginConfig);
+            }
+        }
         const workspaces = Object.entries(initialWorkspaces)
             .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
             .reduce((workspaces, workspace) => {
@@ -131,23 +138,15 @@ export class ConfigurationChief {
                 ignoreBinaries: arrayify(workspaceConfig.ignoreBinaries),
                 ignoreDependencies: arrayify(workspaceConfig.ignoreDependencies),
             };
+            for (const [name, pluginConfig] of Object.entries(rootPluginConfigs)) {
+                const pluginName = toCamelCase(name);
+                if (pluginConfig)
+                    workspaces[workspaceName][pluginName] = pluginConfig;
+            }
             for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
                 const pluginName = toCamelCase(name);
                 if (PLUGIN_NAMES.includes(pluginName)) {
-                    if (pluginConfig === false) {
-                        workspaces[workspaceName][pluginName] = false;
-                    }
-                    else {
-                        const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
-                        const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
-                        const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-                        const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
-                        workspaces[workspaceName][pluginName] = {
-                            config,
-                            entry,
-                            project,
-                        };
-                    }
+                    workspaces[workspaceName][pluginName] = normalizePluginConfig(pluginConfig);
                 }
             }
             return workspaces;
@@ -233,7 +232,7 @@ export class ConfigurationChief {
             : this.availableWorkspaceNames;
         return workspaceNames.sort(byPathDepth).map((name) => ({
             name,
-            pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
+            pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name ?? `NOT_FOUND_${name}`,
             dir: join(this.cwd, name),
             config: this.getConfigForWorkspace(name),
             ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),

package/dist/ConfigurationValidator.d.ts

@@ -1,4 +1,17 @@
 import { z } from 'zod';
+export declare const pluginSchema: z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+    config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    config?: string | string[] | undefined;
+    entry?: string | string[] | undefined;
+    project?: string | string[] | undefined;
+}, {
+    config?: string | string[] | undefined;
+    entry?: string | string[] | undefined;
+    project?: string | string[] | undefined;
+}>]>;
 export declare const ConfigurationValidator: z.ZodObject<{
     exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     rules: z.ZodOptional<z.ZodRecord<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, z.ZodEnum<["error", "warn", "off"]>>>;
@@ -21,6 +34,19 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        angular: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+            config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }>]>>;
         ava: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -535,6 +561,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: string[] | undefined;
         ignoreDependencies?: string[] | undefined;
+        angular?: string | false | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ava?: string | false | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -737,6 +768,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: string[] | undefined;
         ignoreDependencies?: string[] | undefined;
+        angular?: string | false | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ava?: string | false | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -933,6 +969,19 @@ export declare const ConfigurationValidator: z.ZodObject<{
             project?: string | string[] | undefined;
         } | undefined;
     }>>>;
+    angular: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>>;
     ava: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1462,6 +1511,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: string[] | undefined;
         ignoreDependencies?: string[] | undefined;
+        angular?: string | false | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ava?: string | false | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1658,6 +1712,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             project?: string | string[] | undefined;
         } | undefined;
     }> | undefined;
+    angular?: string | false | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     ava?: string | false | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1875,6 +1934,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         ignore?: string | string[] | undefined;
         ignoreBinaries?: string[] | undefined;
         ignoreDependencies?: string[] | undefined;
+        angular?: string | false | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ava?: string | false | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -2071,6 +2135,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             project?: string | string[] | undefined;
         } | undefined;
     }> | undefined;
+    angular?: string | false | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     ava?: string | false | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/ConfigurationValidator.js

@@ -50,7 +50,7 @@ const reportConfigSchema = z.object({
     include: z.array(z.string()).optional(),
     exclude: z.array(z.string()).optional(),
 });
-const pluginSchema = z.union([
+export const pluginSchema = z.union([
     z.literal(false),
     globSchema,
     z.object({
@@ -60,6 +60,7 @@ const pluginSchema = z.union([
     }),
 ]);
 const pluginsSchema = z.object({
+    angular: pluginSchema,
     ava: pluginSchema,
     babel: pluginSchema,
     capacitor: pluginSchema,

package/dist/PrincipalFactory.d.ts

@@ -6,6 +6,7 @@ type Principal = {
     principal: ProjectPrincipal;
     cwds: Set<string>;
     pathKeys: Set<string>;
+    pkgNames: Set<string>;
 };
 type Principals = Set<Principal>;
 type Options = {
@@ -13,6 +14,7 @@ type Options = {
     compilerOptions: ts.CompilerOptions;
     paths: Paths;
     compilers: [SyncCompilers, AsyncCompilers];
+    pkgName: string;
 };
 export declare class PrincipalFactory {
     principals: Principals;
@@ -21,5 +23,6 @@ export declare class PrincipalFactory {
     private linkPrincipal;
     private addNewPrincipal;
     getPrincipals(): ProjectPrincipal[];
+    getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
 }
 export {};

package/dist/PrincipalFactory.js

@@ -12,11 +12,11 @@ const mergePaths = (cwd, compilerOptions, paths = {}) => {
 export class PrincipalFactory {
     principals = new Set();
     getPrincipal(options) {
-        const { cwd, compilerOptions, paths } = options;
+        const { cwd, compilerOptions, paths, pkgName } = options;
         options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
         const principal = this.findReusablePrincipal(compilerOptions);
         if (principal) {
-            this.linkPrincipal(principal, cwd, compilerOptions);
+            this.linkPrincipal(principal, cwd, compilerOptions, pkgName);
             return principal.principal;
         }
         else {
@@ -35,22 +35,26 @@ export class PrincipalFactory {
         });
         return principal;
     }
-    linkPrincipal(principal, cwd, compilerOptions) {
+    linkPrincipal(principal, cwd, compilerOptions, pkgName) {
         const { pathsBasePath, paths } = compilerOptions;
         if (pathsBasePath)
             principal.principal.compilerOptions.pathsBasePath = pathsBasePath;
         Object.keys(paths ?? {}).forEach(p => principal.pathKeys.add(p));
         principal.principal.compilerOptions.paths = { ...principal.principal.compilerOptions.paths, ...paths };
         principal.cwds.add(cwd);
+        principal.pkgNames.add(pkgName);
     }
     addNewPrincipal(options) {
-        const { cwd, compilerOptions } = options;
+        const { cwd, compilerOptions, pkgName } = options;
         const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
         const principal = new ProjectPrincipal(options);
-        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys });
+        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys, pkgNames: new Set([pkgName]) });
         return principal;
     }
     getPrincipals() {
-        return Array.from(this.principals, p => p.principal);
+        return Array.from(this.principals, p => p.principal).reverse();
+    }
+    getPrincipalByPackageName(packageName) {
+        return Array.from(this.principals).find(principal => principal.pkgNames.has(packageName))?.principal;
     }
 }

package/dist/ProjectPrincipal.js

@@ -107,7 +107,7 @@ export class ProjectPrincipal {
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
     analyzeSourceFile(filePath, { skipTypeOnly }) {
-        const sourceFile = this.backend.program?.getSourceFile(filePath);
+        const sourceFile = this.backend.fileManager.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
@@ -192,6 +192,11 @@ export class ProjectPrincipal {
             .map(member => member.identifier);
     }
     findReferences(filePath, pos) {
-        return this.backend.lsFindReferences(filePath, pos) ?? [];
+        try {
+            return this.backend.lsFindReferences(filePath, pos) ?? [];
+        }
+        catch {
+            return [];
+        }
     }
 }

package/dist/WorkspaceWorker.d.ts

@@ -50,7 +50,7 @@ export declare class WorkspaceWorker {
         hostDependencies: HostDependencies;
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
+        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
     }>;
 }
 export {};

package/dist/cli.js

@@ -8,7 +8,7 @@ import { Performance } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { version } from './version.js';
 import { main } from './index.js';
-const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'ignore-internal': isIgnoreInternal = false, 'include-entry-exports': isIncludeEntryExports = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
+const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'ignore-internal': isIgnoreInternal = false, 'include-entry-exports': isIncludeEntryExports = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -40,6 +40,7 @@ const run = async () => {
             isProduction,
             isShowProgress,
             options: reporterOptions,
+            preprocessorOptions,
         };
         const finalData = await runPreprocessors(initialData);
         await runReporters(finalData);

package/dist/index.js

@@ -83,7 +83,7 @@ export const main = async (unresolvedConfiguration) => {
         }
     };
     for (const workspace of workspaces) {
-        const { name, dir, config, ancestors } = workspace;
+        const { name, dir, config, ancestors, pkgName } = workspace;
         const { paths, ignoreDependencies, ignoreBinaries } = config;
         const isRoot = name === ROOT_WORKSPACE_NAME;
         streamer.cast(`Analyzing workspace (${name})...`);
@@ -93,7 +93,7 @@ export const main = async (unresolvedConfiguration) => {
             throw new LoaderError(`Unable to load package.json for ${name}`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const compilerOptions = await loadCompilerOptions(join(dir, tsConfigFile ?? 'tsconfig.json'));
-        const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers });
+        const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers, pkgName });
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -176,21 +176,33 @@ export const main = async (unresolvedConfiguration) => {
     }
     const principals = factory.getPrincipals();
     debugLog(`Installed ${principals.length} principals for ${workspaces.length} workspaces`);
+    const analyzedFiles = new Set();
+    const exportedSymbols = new Map();
+    const importedSymbols = new Map();
     for (const principal of principals) {
-        const exportedSymbols = new Map();
-        const importedSymbols = new Map();
-        const analyzeSourceFile = (filePath) => {
+        const analyzeSourceFile = (filePath, _principal = principal) => {
             const workspace = chief.findWorkspaceByFilePath(filePath);
             if (workspace) {
-                const { imports, exports, scripts } = principal.analyzeSourceFile(filePath, { skipTypeOnly: isProduction });
+                const { imports, exports, scripts } = _principal.analyzeSourceFile(filePath, { skipTypeOnly: isProduction });
                 const { internal, external, unresolved } = imports;
                 const { exported, duplicate } = exports;
                 if (exported.size > 0)
                     exportedSymbols.set(filePath, exported);
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
-                    if (packageName && chief.localWorkspaces.has(packageName))
+                    if (packageName && chief.localWorkspaces.has(packageName)) {
                         external.add(packageName);
+                        if (_principal === principal) {
+                            const workspace = chief.findWorkspaceByFilePath(specifierFilePath);
+                            if (workspace) {
+                                const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                                if (principal && !principal.isGitIgnored(specifierFilePath)) {
+                                    analyzeSourceFile(specifierFilePath, principal);
+                                    analyzedFiles.add(specifierFilePath);
+                                }
+                            }
+                        }
+                    }
                     if (!importedSymbols.has(specifierFilePath)) {
                         importedSymbols.set(specifierFilePath, importItems);
                     }
@@ -223,14 +235,13 @@ export const main = async (unresolvedConfiguration) => {
                     collector.addIssue({ type: 'unresolved', filePath, symbol: moduleSpecifier });
                 });
                 _getDependenciesFromScripts(scripts, { cwd: dirname(filePath) }).forEach(specifier => {
-                    handleReferencedDependency({ specifier, containingFilePath: filePath, principal, workspace });
+                    handleReferencedDependency({ specifier, containingFilePath: filePath, principal: _principal, workspace });
                 });
             }
         };
         streamer.cast('Running async compilers...');
         await principal.runAsyncCompilers();
         streamer.cast('Connecting the dots...');
-        const analyzedFiles = new Set();
         let size = principal.entryPaths.size;
         let round = 0;
         do {
@@ -243,37 +254,38 @@ export const main = async (unresolvedConfiguration) => {
                 analyzedFiles.add(filePath);
             });
         } while (size !== principal.entryPaths.size);
-        const unusedFiles = principal.getUnreferencedFiles();
-        collector.addFilesIssues(unusedFiles);
-        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
-        const isSymbolImported = (symbol, importingModule) => {
-            if (!importingModule)
-                return false;
-            if (importingModule.symbols.has(symbol))
-                return true;
-            const { isReExport, isReExportedBy } = importingModule;
-            const hasSymbol = (file) => isSymbolImported(symbol, importedSymbols.get(file));
-            return isReExport ? Array.from(isReExportedBy).some(hasSymbol) : false;
-        };
-        const isExportedInEntryFile = (importedModule) => {
-            if (!importedModule)
-                return false;
-            const { isReExport, isReExportedBy } = importedModule;
-            const { entryPaths } = principal;
-            const hasFile = (file) => entryPaths.has(file) || isExportedInEntryFile(importedSymbols.get(file));
-            return isReExport ? Array.from(isReExportedBy).some(hasFile) : false;
-        };
-        const isExportedItemReferenced = (exportedItem, filePath) => {
-            const hasReferences = principal.getHasReferences(filePath, exportedItem);
-            return (hasReferences.external ||
-                (hasReferences.internal &&
-                    (typeof chief.config.ignoreExportsUsedInFile === 'object'
-                        ? exportedItem.type !== 'unknown' && !!chief.config.ignoreExportsUsedInFile[exportedItem.type]
-                        : chief.config.ignoreExportsUsedInFile)));
-        };
-        if (isReportValues || isReportTypes) {
-            streamer.cast('Analyzing source files...');
-            for (const [filePath, exportItems] of exportedSymbols.entries()) {
+    }
+    const isSymbolImported = (symbol, importingModule) => {
+        if (!importingModule)
+            return false;
+        if (importingModule.symbols.has(symbol))
+            return true;
+        const { isReExport, isReExportedBy } = importingModule;
+        const hasSymbol = (file) => isSymbolImported(symbol, importedSymbols.get(file));
+        return isReExport ? Array.from(isReExportedBy).some(hasSymbol) : false;
+    };
+    const isExportedInEntryFile = (principal, importedModule) => {
+        if (!importedModule)
+            return false;
+        const { isReExport, isReExportedBy } = importedModule;
+        const { entryPaths } = principal;
+        const hasFile = (file) => entryPaths.has(file) || isExportedInEntryFile(principal, importedSymbols.get(file));
+        return isReExport ? Array.from(isReExportedBy).some(hasFile) : false;
+    };
+    const isExportedItemReferenced = (principal, exportedItem, filePath) => {
+        const hasReferences = principal.getHasReferences(filePath, exportedItem);
+        return (hasReferences.external ||
+            (hasReferences.internal &&
+                (typeof chief.config.ignoreExportsUsedInFile === 'object'
+                    ? exportedItem.type !== 'unknown' && !!chief.config.ignoreExportsUsedInFile[exportedItem.type]
+                    : chief.config.ignoreExportsUsedInFile)));
+    };
+    if (isReportValues || isReportTypes) {
+        streamer.cast('Analyzing source files...');
+        for (const [filePath, exportItems] of exportedSymbols.entries()) {
+            const workspace = chief.findWorkspaceByFilePath(filePath);
+            const principal = workspace && factory.getPrincipalByPackageName(workspace.pkgName);
+            if (principal) {
                 if (!isIncludeEntryExports && principal.entryPaths.has(filePath))
                     continue;
                 const importingModule = importedSymbols.get(filePath);
@@ -283,7 +295,7 @@ export const main = async (unresolvedConfiguration) => {
                     if (isIgnoreInternal && exportedItem.jsDocTags.has('@internal'))
                         continue;
                     if (importingModule && isSymbolImported(symbol, importingModule)) {
-                        if (importingModule.isReExport && isExportedInEntryFile(importingModule))
+                        if (importingModule.isReExport && isExportedInEntryFile(principal, importingModule))
                             continue;
                         if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
                             if (isProduction)
@@ -300,8 +312,8 @@ export const main = async (unresolvedConfiguration) => {
                         continue;
                     }
                     const isStar = Boolean(importingModule?.isStar);
-                    const isReExportedByEntryFile = !isIncludeEntryExports && isStar && isExportedInEntryFile(importingModule);
-                    if (!isReExportedByEntryFile && !isExportedItemReferenced(exportedItem, filePath)) {
+                    const isReExportedByEntryFile = !isIncludeEntryExports && isStar && isExportedInEntryFile(principal, importingModule);
+                    if (!isReExportedByEntryFile && !isExportedItemReferenced(principal, exportedItem, filePath)) {
                         if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
                             if (isProduction)
                                 continue;
@@ -317,6 +329,12 @@ export const main = async (unresolvedConfiguration) => {
             }
         }
     }
+    const unusedFiles = factory
+        .getPrincipals()
+        .flatMap(principal => principal.getUnreferencedFiles())
+        .filter(filePath => !analyzedFiles.has(filePath));
+    collector.addFilesIssues(unusedFiles);
+    collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
     if (isReportDependencies) {
         const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
         const { configurationHints } = deputy.getConfigurationHints();

package/dist/manifest/index.js

@@ -6,7 +6,7 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
     const hostDependencies = new Map();
     const scripts = Object.entries(manifest.scripts ?? {}).reduce((scripts, [scriptName, script]) => {
         if (script && (scriptFilter.length === 0 || scriptFilter.includes(scriptName))) {
-            return [...scripts, script];
+            scripts.push(script);
         }
         return scripts;
     }, []);

package/dist/plugins/angular/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Angular";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/angular/index.js

@@ -0,0 +1,36 @@
+import { join } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { findTypeScriptDependencies } from '../typescript/index.js';
+export const NAME = 'Angular';
+export const ENABLERS = ['@angular/cli'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['angular.json'];
+const findPluginDependencies = async (configFilePath, opts) => {
+    const { cwd } = opts;
+    const config = await load(configFilePath);
+    if (!config.projects)
+        return [];
+    const dependencies = new Set();
+    for (const project of Object.values(config.projects)) {
+        if (!project.architect)
+            return [];
+        for (const target of Object.values(project.architect)) {
+            const { options } = target;
+            const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];
+            if (typeof packageName === 'string')
+                dependencies.add(packageName);
+            if (options) {
+                if ('main' in options && typeof options?.main === 'string') {
+                    dependencies.add(join(cwd, options.main));
+                }
+                if ('tsConfig' in options && typeof options.tsConfig === 'string') {
+                    const tsConfigDependencies = await findTypeScriptDependencies(join(cwd, options.tsConfig), opts);
+                    tsConfigDependencies.forEach(dependency => dependencies.add(dependency));
+                }
+            }
+        }
+    }
+    return Array.from(dependencies);
+};
+export const findDependencies = timerify(findPluginDependencies);