knip 0.0.0-angular.0

package/dist/index.js

@@ -0,0 +1,334 @@
+import micromatch from 'micromatch';
+import { _getDependenciesFromScripts } from './binaries/index.js';
+import { fromBinary, isBinary } from './binaries/util.js';
+import { ConfigurationChief } from './ConfigurationChief.js';
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import { ROOT_WORKSPACE_NAME } from './constants.js';
+import { DependencyDeputy } from './DependencyDeputy.js';
+import { IssueCollector } from './IssueCollector.js';
+import { PrincipalFactory } from './PrincipalFactory.js';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
+import { compact } from './util/array.js';
+import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
+import { LoaderError } from './util/errors.js';
+import { findFile } from './util/fs.js';
+import { _glob } from './util/glob.js';
+import { getEntryPathFromManifest, getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, } from './util/modules.js';
+import { dirname, isInNodeModules, join, isInternal, toAbsolute } from './util/path.js';
+import { _resolveSpecifier, _tryResolve } from './util/require.js';
+import { _require } from './util/require.js';
+import { loadTSConfig as loadCompilerOptions } from './util/tsconfig-loader.js';
+import { WorkspaceWorker } from './WorkspaceWorker.js';
+export const main = async (unresolvedConfiguration) => {
+    const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isIgnoreInternal, isShowProgress, isIncludeEntryExports, } = unresolvedConfiguration;
+    debugLogObject('Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
+    const chief = new ConfigurationChief({ cwd, isProduction });
+    const deputy = new DependencyDeputy({ isStrict });
+    const factory = new PrincipalFactory();
+    const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
+    streamer.cast('Reading workspace configuration(s)...');
+    await chief.init();
+    const compilers = chief.getCompilers();
+    const workspaces = chief.getWorkspaces();
+    const report = chief.getIssueTypesToReport();
+    const rules = chief.getRules();
+    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
+    const isReportValues = report.exports || report.nsExports || report.classMembers;
+    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
+    const collector = new IssueCollector({ cwd, rules });
+    const enabledPluginsStore = new Map();
+    deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
+    debugLogObject('Included workspaces', workspaces);
+    const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
+        if (isInternal(specifier)) {
+            const absSpecifier = toAbsolute(specifier, dirname(containingFilePath));
+            const filePath = _tryResolve(absSpecifier, containingFilePath);
+            if (filePath) {
+                const ignorePatterns = workspace.config.ignore.map(pattern => join(dirname(containingFilePath), pattern));
+                const isIgnored = micromatch.isMatch(filePath, ignorePatterns);
+                if (!isIgnored)
+                    principal.addEntryPath(filePath);
+            }
+            else {
+                collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+            }
+        }
+        else {
+            if (isBinary(specifier)) {
+                const binaryName = fromBinary(specifier);
+                const isHandled = deputy.maybeAddReferencedBinary(workspace, binaryName);
+                if (!isHandled)
+                    collector.addIssue({ type: 'binaries', filePath: containingFilePath, symbol: binaryName });
+            }
+            else {
+                const packageName = isInNodeModules(specifier)
+                    ? getPackageNameFromFilePath(specifier)
+                    : getPackageNameFromModuleSpecifier(specifier);
+                const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(workspace, packageName);
+                if (!isHandled)
+                    collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
+                if (packageName && specifier !== packageName) {
+                    const otherWorkspace = chief.findWorkspaceByPackageName(packageName);
+                    if (otherWorkspace) {
+                        const filePath = _resolveSpecifier(otherWorkspace.dir, specifier);
+                        if (filePath) {
+                            principal.addEntryPath(filePath, { skipExportsAnalysis: true });
+                        }
+                        else {
+                            collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+                        }
+                    }
+                }
+            }
+        }
+    };
+    for (const workspace of workspaces) {
+        const { name, dir, config, ancestors } = workspace;
+        const { paths, ignoreDependencies, ignoreBinaries } = config;
+        const isRoot = name === ROOT_WORKSPACE_NAME;
+        streamer.cast(`Analyzing workspace (${name})...`);
+        const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
+        const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
+        if (!manifestPath || !manifest)
+            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 worker = new WorkspaceWorker({
+            name,
+            dir,
+            cwd,
+            config,
+            manifest,
+            isProduction,
+            isStrict,
+            rootIgnore: chief.config.ignore,
+            negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
+            enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
+        });
+        await worker.init();
+        const sharedGlobOptions = { cwd, workingDir: dir, gitignore, ignore: worker.getIgnorePatterns() };
+        const entryPathsFromManifest = await getEntryPathFromManifest(cwd, dir, manifest);
+        debugLogArray(`Found entry paths from manifest (${name})`, entryPathsFromManifest);
+        principal.addEntryPaths(entryPathsFromManifest);
+        if (isProduction) {
+            {
+                const patterns = worker.getProductionEntryFilePatterns();
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
+                principal.addEntryPaths(workspaceEntryPaths);
+            }
+            {
+                const patterns = worker.getProductionPluginEntryFilePatterns();
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found production plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
+                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+            }
+            {
+                const patterns = worker.getProductionProjectFilePatterns();
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
+                workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+            }
+        }
+        else {
+            {
+                const patterns = worker.getEntryFilePatterns();
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
+                principal.addEntryPaths(workspaceEntryPaths);
+            }
+            {
+                const patterns = worker.getProjectFilePatterns();
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
+                workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+            }
+            {
+                const patterns = worker.getPluginEntryFilePatterns();
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
+                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+            }
+            {
+                const patterns = worker.getPluginProjectFilePatterns();
+                const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin project paths (${name})`, pluginWorkspaceProjectPaths);
+                pluginWorkspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
+            }
+            {
+                const patterns = compact(worker.getPluginConfigPatterns());
+                const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin configuration paths (${name})`, configurationEntryPaths);
+                principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
+            }
+        }
+        if (chief.resolvedConfigFilePath)
+            principal.addEntryPath(chief.resolvedConfigFilePath, { skipExportsAnalysis: true });
+        const dependencies = await worker.findAllDependencies();
+        const { referencedDependencies, peerDependencies, installedBinaries, enabledPlugins } = dependencies;
+        deputy.addPeerDependencies(name, peerDependencies);
+        deputy.setInstalledBinaries(name, installedBinaries);
+        enabledPluginsStore.set(name, enabledPlugins);
+        referencedDependencies.forEach(([containingFilePath, specifier]) => {
+            handleReferencedDependency({ specifier, containingFilePath, principal, workspace });
+        });
+    }
+    const principals = factory.getPrincipals();
+    debugLog(`Installed ${principals.length} principals for ${workspaces.length} workspaces`);
+    for (const principal of principals) {
+        const exportedSymbols = new Map();
+        const importedSymbols = new Map();
+        const analyzeSourceFile = (filePath) => {
+            const workspace = chief.findWorkspaceByFilePath(filePath);
+            if (workspace) {
+                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))
+                        external.add(packageName);
+                    if (!importedSymbols.has(specifierFilePath)) {
+                        importedSymbols.set(specifierFilePath, importItems);
+                    }
+                    else {
+                        const importedModule = importedSymbols.get(specifierFilePath);
+                        for (const identifier of importItems.symbols) {
+                            importedModule.symbols.add(identifier);
+                        }
+                        if (importItems.isReExport) {
+                            importedModule.isReExport = importItems.isReExport;
+                            importedModule.isReExportedBy.add(filePath);
+                        }
+                        if (importItems.isStar)
+                            importedModule.isStar = importItems.isStar;
+                    }
+                }
+                duplicate.forEach(symbols => {
+                    if (symbols.length > 1) {
+                        const symbol = symbols.join('|');
+                        collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
+                    }
+                });
+                external.forEach(specifier => {
+                    const packageName = getPackageNameFromModuleSpecifier(specifier);
+                    const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(workspace, packageName);
+                    if (!isHandled)
+                        collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
+                });
+                unresolved.forEach(moduleSpecifier => {
+                    collector.addIssue({ type: 'unresolved', filePath, symbol: moduleSpecifier });
+                });
+                _getDependenciesFromScripts(scripts, { cwd: dirname(filePath) }).forEach(specifier => {
+                    handleReferencedDependency({ specifier, containingFilePath: filePath, 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 {
+            size = principal.entryPaths.size;
+            const resolvedFiles = principal.getUsedResolvedFiles();
+            const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
+            debugLogArray(`Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
+            files.forEach(filePath => {
+                analyzeSourceFile(filePath);
+                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()) {
+                if (!isIncludeEntryExports && principal.entryPaths.has(filePath))
+                    continue;
+                const importingModule = importedSymbols.get(filePath);
+                for (const [symbol, exportedItem] of exportItems.entries()) {
+                    if (exportedItem.jsDocTags.includes('@public') || exportedItem.jsDocTags.includes('@beta'))
+                        continue;
+                    if (isIgnoreInternal && exportedItem.jsDocTags.includes('@internal'))
+                        continue;
+                    if (importingModule && isSymbolImported(symbol, importingModule)) {
+                        if (importingModule.isReExport && isExportedInEntryFile(importingModule))
+                            continue;
+                        if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
+                            if (isProduction)
+                                continue;
+                            principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
+                                collector.addIssue({ type: 'enumMembers', filePath, symbol: member, parentSymbol: symbol });
+                            });
+                        }
+                        if (report.classMembers && exportedItem.type === 'class' && exportedItem.members) {
+                            principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
+                                collector.addIssue({ type: 'classMembers', filePath, symbol: member, parentSymbol: symbol });
+                            });
+                        }
+                        continue;
+                    }
+                    const isStar = Boolean(importingModule?.isStar);
+                    const isReExportedByEntryFile = !isIncludeEntryExports && isStar && isExportedInEntryFile(importingModule);
+                    if (!isReExportedByEntryFile && !isExportedItemReferenced(exportedItem, filePath)) {
+                        if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
+                            if (isProduction)
+                                continue;
+                            const type = isStar ? 'nsTypes' : 'types';
+                            collector.addIssue({ type, filePath, symbol, symbolType: exportedItem.type });
+                        }
+                        else {
+                            const type = isStar ? 'nsExports' : 'exports';
+                            collector.addIssue({ type, filePath, symbol });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (isReportDependencies) {
+        const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
+        const { configurationHints } = deputy.getConfigurationHints();
+        dependencyIssues.forEach(issue => collector.addIssue(issue));
+        if (!isProduction)
+            devDependencyIssues.forEach(issue => collector.addIssue(issue));
+        optionalPeerDependencyIssues.forEach(issue => collector.addIssue(issue));
+        configurationHints.forEach(hint => collector.addConfigurationHint(hint));
+    }
+    const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
+    unusedIgnoredWorkspaces.forEach(identifier => collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier }));
+    const { issues, counters, configurationHints } = collector.getIssues();
+    streamer.clear();
+    return { report, issues, counters, rules, configurationHints };
+};

package/dist/issues/initializers.d.ts

@@ -0,0 +1,4 @@
+import type { Issues, Counters, Rules } from '../types/issues.js';
+export declare const initIssues: () => Issues;
+export declare const initCounters: () => Counters;
+export declare const defaultRules: Rules;

package/dist/issues/initializers.js

@@ -0,0 +1,11 @@
+import { ISSUE_TYPES } from '../constants.js';
+export const initIssues = () => ({
+    ...Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, {}])),
+    files: new Set(),
+});
+export const initCounters = () => ({
+    ...Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, 0])),
+    processed: 0,
+    total: 0,
+});
+export const defaultRules = Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, 'error']));

package/dist/manifest/helpers.d.ts

@@ -0,0 +1,7 @@
+type Options = {
+    dir: string;
+    packageName: string;
+    cwd: string;
+};
+export declare const getPackageManifest: ({ dir, packageName, cwd }: Options) => Promise<any>;
+export {};

package/dist/manifest/helpers.js

@@ -0,0 +1,16 @@
+import { join } from '../util/path.js';
+import { _require } from '../util/require.js';
+export const getPackageManifest = async ({ dir, packageName, cwd }) => {
+    try {
+        return _require(join(dir, 'node_modules', packageName, 'package.json'));
+    }
+    catch (error) {
+        if (dir !== cwd) {
+            try {
+                return _require(join(cwd, 'node_modules', packageName, 'package.json'));
+            }
+            catch (error) {
+            }
+        }
+    }
+};

package/dist/manifest/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="npmcli__package-json" />
+import type { InstalledBinaries, PeerDependencies } from '../types/workspace.js';
+import type { PackageJson } from '@npmcli/package-json';
+type Options = {
+    manifest: PackageJson;
+    isProduction: boolean;
+    isStrict: boolean;
+    dir: string;
+    cwd: string;
+};
+export declare const findDependencies: ({ manifest, isProduction, isStrict, dir, cwd }: Options) => Promise<{
+    dependencies: string[];
+    peerDependencies: PeerDependencies;
+    installedBinaries: InstalledBinaries;
+}>;
+export {};

package/dist/manifest/index.js

@@ -0,0 +1,56 @@
+import { _getDependenciesFromScripts } from '../binaries/index.js';
+import { timerify } from '../util/Performance.js';
+import { getPackageManifest } from './helpers.js';
+const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir, cwd }) => {
+    const scriptFilter = isProduction ? ['start', 'postinstall'] : [];
+    const peerDependencies = new Map();
+    const scripts = Object.entries(manifest.scripts ?? {}).reduce((scripts, [scriptName, script]) => {
+        if (script && (scriptFilter.length === 0 || scriptFilter.includes(scriptName))) {
+            return [...scripts, script];
+        }
+        return scripts;
+    }, []);
+    const dependencies = _getDependenciesFromScripts(scripts, { cwd: dir, manifest });
+    const installedBinaries = new Map();
+    const packageNames = [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...(isStrict ? Object.keys(manifest.peerDependencies ?? {}) : []),
+        ...(isProduction ? [] : Object.keys(manifest.devDependencies ?? {})),
+    ];
+    for (const packageName of packageNames) {
+        const manifest = await getPackageManifest({ dir, packageName, cwd });
+        if (manifest) {
+            const binaryName = packageName.replace(/^@[^/]+\//, '');
+            const binaries = typeof manifest.bin === 'string' ? [binaryName] : Object.keys(manifest.bin ?? {});
+            binaries.forEach(binaryName => {
+                if (installedBinaries.has(binaryName)) {
+                    installedBinaries.get(binaryName)?.add(packageName);
+                }
+                else {
+                    installedBinaries.set(binaryName, new Set([packageName]));
+                }
+                if (installedBinaries.has(packageName)) {
+                    installedBinaries.get(packageName)?.add(binaryName);
+                }
+                else {
+                    installedBinaries.set(packageName, new Set([binaryName]));
+                }
+            });
+            const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
+            packagePeerDependencies.forEach(packagePeerDependency => {
+                if (peerDependencies.has(packagePeerDependency)) {
+                    peerDependencies.get(packagePeerDependency)?.add(packageName);
+                }
+                else {
+                    peerDependencies.set(packagePeerDependency, new Set([packageName]));
+                }
+            });
+        }
+    }
+    return {
+        dependencies,
+        peerDependencies,
+        installedBinaries,
+    };
+};
+export const findDependencies = timerify(findManifestDependencies);

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

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

package/dist/plugins/_template/index.js

@@ -0,0 +1,14 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = '';
+export const ENABLERS = [''];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [];
+export const ENTRY_FILE_PATTERNS = [];
+export const PRODUCTION_ENTRY_FILE_PATTERNS = [];
+export const PROJECT_FILE_PATTERNS = [];
+const findPluginDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json') ? manifest.plugin : await load(configFilePath);
+    return config?.plugins ?? [];
+};
+export const findDependencies = timerify(findPluginDependencies);

package/dist/plugins/_template/types.d.ts

@@ -0,0 +1,3 @@
+export type PluginConfig = {
+    plugins?: string[];
+};

package/dist/plugins/_template/types.js

@@ -0,0 +1 @@
+export {};

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);