knip 5.63.0 → 5.64.0

package/dist/graph/analyze.js

@@ -4,16 +4,10 @@ import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
 import { createAndPrintTrace, printTrace } from '../util/trace.js';
-export const analyze = async (options) => {
-    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, } = options;
-    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved || report.binaries;
-    const isReportValues = report.exports || report.nsExports || report.classMembers;
-    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
-    const isReportClassMembers = report.classMembers;
-    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
-    const shouldIgnore = getShouldIgnoreHandler(isProduction);
-    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
+export const analyze = async ({ analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }) => {
+    const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
@@ -21,7 +15,7 @@ export const analyze = async (options) => {
                 ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
                 : ignoreExportsUsedInFile));
     const analyzeGraph = async () => {
-        if (isReportValues || isReportTypes) {
+        if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
             for (const [filePath, file] of graph.entries()) {
                 const exportItems = file.exports;
@@ -33,7 +27,7 @@ export const analyze = async (options) => {
                     const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
-                        createAndPrintTrace(filePath, { isEntry });
+                        createAndPrintTrace(filePath, options, { isEntry });
                         continue;
                     }
                     const importsForExport = file.imported;
@@ -45,7 +39,7 @@ export const analyze = async (options) => {
                             const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
                             if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
-                                    if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                     }
                                 }
@@ -54,7 +48,7 @@ export const analyze = async (options) => {
                                 continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
-                                    createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
+                                    createAndPrintTrace(filePath, options, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
                                 const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
@@ -62,10 +56,10 @@ export const analyze = async (options) => {
                                     continue;
                             }
                             if (traceNode)
-                                printTrace(traceNode, filePath, identifier);
+                                printTrace(traceNode, filePath, options, identifier);
                             if (isReferenced) {
-                                if (report.enumMembers && exportedItem.type === 'enum') {
-                                    if (!report.nsTypes && importsForExport.refs.has(identifier))
+                                if (options.includedIssueTypes.enumMembers && exportedItem.type === 'enum') {
+                                    if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
                                         continue;
                                     if (hasStrictlyEnumReferences(importsForExport, identifier))
                                         continue;
@@ -91,12 +85,12 @@ export const analyze = async (options) => {
                                                     line: member.line,
                                                     col: member.col,
                                                 });
-                                                if (isFix && isIssueAdded && member.fix)
+                                                if (options.isFix && isIssueAdded && member.fix)
                                                     fixer.addUnusedTypeNode(filePath, [member.fix]);
                                             }
                                             else if (isIgnored) {
                                                 for (const tagName of exportedItem.jsDocTags) {
-                                                    if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                                         collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
                                                     }
                                                 }
@@ -104,13 +98,13 @@ export const analyze = async (options) => {
                                         }
                                     }
                                 }
-                                if (principal && isReportClassMembers && exportedItem.type === 'class') {
+                                if (principal && options.isReportClassMembers && exportedItem.type === 'class') {
                                     const members = exportedItem.members.filter(member => !(findMatch(workspace.ignoreMembers, member.identifier) || shouldIgnore(member.jsDocTags)));
                                     for (const member of principal.findUnusedMembers(filePath, members)) {
                                         if (shouldIgnoreTags(member.jsDocTags)) {
                                             const identifier = `${exportedItem.identifier}.${member.identifier}`;
                                             for (const tagName of exportedItem.jsDocTags) {
-                                                if (tags[1].includes(tagName.replace(/^@/, ''))) {
+                                                if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                                     collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                                 }
                                             }
@@ -126,7 +120,7 @@ export const analyze = async (options) => {
                                             line: member.line,
                                             col: member.col,
                                         });
-                                        if (isFix && isIssueAdded && member.fix)
+                                        if (options.isFix && isIssueAdded && member.fix)
                                             fixer.addUnusedTypeNode(filePath, [member.fix]);
                                     }
                                 }
@@ -135,12 +129,13 @@ export const analyze = async (options) => {
                         }
                         const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
-                        if (hasStrictlyNsRefs && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
+                        if (hasStrictlyNsRefs &&
+                            ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
                             continue;
                         if (!isExportedItemReferenced(exportedItem)) {
                             if (isIgnored)
                                 continue;
-                            if (!isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
+                            if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
                             const type = getType(hasStrictlyNsRefs, isType);
                             const isIssueAdded = collector.addIssue({
@@ -154,7 +149,7 @@ export const analyze = async (options) => {
                                 line: exportedItem.line,
                                 col: exportedItem.col,
                             });
-                            if (isFix && isIssueAdded) {
+                            if (options.isFix && isIssueAdded) {
                                 if (isType)
                                     fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
                                 else
@@ -177,16 +172,19 @@ export const analyze = async (options) => {
                     }
                 }
                 if (file.imports?.external) {
-                    for (const specifier of file.imports.external) {
-                        const packageName = getPackageNameFromModuleSpecifier(specifier);
+                    for (const extImport of file.imports.external) {
+                        const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(ws, packageName);
                         if (!isHandled)
                             collector.addIssue({
                                 type: 'unlisted',
                                 filePath,
                                 workspace: ws.name,
-                                symbol: packageName ?? specifier,
-                                specifier,
+                                symbol: packageName ?? extImport.specifier,
+                                specifier: extImport.specifier,
+                                pos: extImport.pos,
+                                line: extImport.line,
+                                col: extImport.col,
                             });
                     }
                 }
@@ -201,11 +199,11 @@ export const analyze = async (options) => {
         const unusedFiles = [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath));
         collector.addFilesIssues(unusedFiles);
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
-        if (isReportDependencies) {
+        if (options.isReportDependencies) {
             const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
             for (const issue of dependencyIssues)
                 collector.addIssue(issue);
-            if (!isProduction)
+            if (!options.isProduction)
                 for (const issue of devDependencyIssues)
                     collector.addIssue(issue);
             for (const issue of optionalPeerDependencyIssues)
@@ -219,6 +217,8 @@ export const analyze = async (options) => {
         for (const identifier of unusedIgnoredWorkspaces) {
             collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
         }
+        for (const hint of chief.getConfigurationHints())
+            collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
     return analyzeGraph;

package/dist/graph/build.d.ts

@@ -4,33 +4,19 @@ import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
 import type { PrincipalFactory } from '../PrincipalFactory.js';
 import type { ProjectPrincipal } from '../ProjectPrincipal.js';
-import type { Tags } from '../types/cli.js';
-import type { Report } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
+import type { MainOptions } from '../util/create-options.js';
 interface BuildOptions {
-    cacheLocation: string;
     chief: ConfigurationChief;
     collector: IssueCollector;
-    cwd: string;
     deputy: DependencyDeputy;
     factory: PrincipalFactory;
-    gitignore: boolean;
-    isCache: boolean;
-    isFixExports: boolean;
-    isFixTypes: boolean;
     isGitIgnored: (path: string) => boolean;
-    isIsolateWorkspaces: boolean;
-    isProduction: boolean;
-    isSkipLibs: boolean;
-    isStrict: boolean;
-    isWatch: boolean;
-    report: Report;
     streamer: ConsoleStreamer;
-    tags: Tags;
-    tsConfigFile?: string;
     workspaces: Workspace[];
+    options: MainOptions;
 }
-export declare function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }: BuildOptions): Promise<{
+export declare function build({ chief, collector, deputy, factory, isGitIgnored, streamer, workspaces, options, }: BuildOptions): Promise<{
     graph: ModuleGraph;
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;

package/dist/graph/build.js

@@ -13,19 +13,26 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, join, relative, toRelative } from '../util/path.js';
 import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
-export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
+export async function build({ chief, collector, deputy, factory, isGitIgnored, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const toSourceFilePaths = getToSourcePathsHandler(chief);
     const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
-    const isReportClassMembers = report.classMembers;
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
         if (!manifest)
             continue;
-        deputy.addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ...chief.getIgnores(name) });
+        deputy.addWorkspace({
+            name,
+            cwd: options.cwd,
+            dir,
+            manifestPath,
+            manifestStr,
+            manifest,
+            ...chief.getIgnores(name),
+        });
     }
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName, manifestPath: filePath } = workspace;
@@ -38,29 +45,25 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         const extensions = getCompilerExtensions(compilers);
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
-        const tsConfigFilePath = join(dir, tsConfigFile ?? 'tsconfig.json');
+        const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(tsConfigFilePath);
         if (isFile)
             augmentWorkspace(workspace, dir, compilerOptions);
         const worker = new WorkspaceWorker({
             name,
             dir,
-            cwd,
             config,
             manifest,
             dependencies,
             getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
-            isProduction,
-            isStrict,
             rootIgnore: chief.config.ignore,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
             getSourceFile: (filePath) => principal.backend.fileManager.getSourceFile(filePath),
-            isCache,
-            cacheLocation,
             configFilesMap,
+            options,
         });
         await worker.init();
         const inputs = new Set();
@@ -70,8 +73,8 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 inputs.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
         }
         const ignore = worker.getIgnorePatterns();
-        const sharedGlobOptions = { cwd, dir, gitignore };
-        collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
+        const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
+        collector.addIgnorePatterns(ignore.map(pattern => join(options.cwd, pattern)));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
         for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr)) {
             inputs.add(toProductionEntry(filePath));
@@ -86,19 +89,13 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         }
         for (const dep of getManifestImportDependencies(manifest))
             deputy.addReferencedDependency(name, dep);
-        const principal = factory.createPrincipal({
-            cwd: dir,
+        const principal = factory.createPrincipal(options, {
+            dir,
             isFile,
             compilerOptions,
             compilers,
             pkgName,
-            isIsolateWorkspaces,
-            isSkipLibs,
-            isWatch,
             toSourceFilePath,
-            isCache,
-            cacheLocation,
-            isProduction,
         });
         principal.addPaths(config.paths, dir);
         const inputsFromPlugins = await worker.runPlugins();
@@ -152,7 +149,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                         productionPatternsSkipExports.add(resolvedFilePath);
                     }
                     else if (isDeferResolveEntry(input)) {
-                        if (!isProduction || !input.optional)
+                        if (!options.isProduction || !input.optional)
                             entryPatternsSkipExports.add(resolvedFilePath);
                     }
                     else {
@@ -161,7 +158,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 }
             }
         }
-        if (isProduction) {
+        if (options.isProduction) {
             const negatedEntryPatterns = [...entryPatterns, ...entryPatternsSkipExports].map(negate);
             {
                 const label = 'entry paths';
@@ -238,8 +235,8 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                     principal.addProjectPath(projectPath);
             }
         }
-        if (chief.resolvedConfigFilePath) {
-            principal.addEntryPath(chief.resolvedConfigFilePath, { skipExportsAnalysis: true });
+        if (options.configFilePath) {
+            factory.getPrincipals().at(0)?.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
         }
         worker.onDispose();
     }
@@ -255,28 +252,28 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         if (workspace)
             return factory.getPrincipalByPackageName(workspace.pkgName);
     };
+    const analyzeOpts = {
+        isFixExports: options.isFixUnusedExports,
+        isFixTypes: options.isFixUnusedTypes,
+        isReportClassMembers: options.isReportClassMembers,
+        skipTypeOnly: options.isStrict,
+        tags: options.tags,
+    };
     const analyzeSourceFile = (filePath, principal) => {
-        if (!isWatch && analyzedFiles.has(filePath))
+        if (!options.isWatch && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const file = principal.analyzeSourceFile(filePath, {
-                skipTypeOnly: isStrict,
-                isFixExports,
-                isFixTypes,
-                ignoreExportsUsedInFile: chief.config.ignoreExportsUsedInFile,
-                isReportClassMembers,
-                tags,
-            });
-            const _unresolved = new Set();
+            const file = principal.analyzeSourceFile(filePath, analyzeOpts, chief.config.ignoreExportsUsedInFile);
+            const unresolvedImports = new Set();
             for (const unresolvedImport of file.imports.unresolved) {
                 const { specifier } = unresolvedImport;
                 if (specifier.startsWith('http'))
                     continue;
                 const sanitizedSpecifier = sanitizeSpecifier(specifier);
                 if (isStartsLikePackageName(sanitizedSpecifier)) {
-                    file.imports.external.add(sanitizedSpecifier);
+                    file.imports.external.add({ ...unresolvedImport, specifier: sanitizedSpecifier });
                 }
                 else {
                     const isIgnored = isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
@@ -284,7 +281,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                         const ext = extname(sanitizedSpecifier);
                         const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
                         if (!ext || (ext !== '.json' && !hasIgnoredExtension))
-                            _unresolved.add(unresolvedImport);
+                            unresolvedImports.add(unresolvedImport);
                     }
                 }
             }
@@ -293,10 +290,10 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 if (!isIgnored)
                     principal.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
-            for (const [specifier, specifierFilePath] of file.imports.specifiers) {
-                const packageName = getPackageNameFromModuleSpecifier(specifier);
+            for (const [import_, specifierFilePath] of file.imports.specifiers) {
+                const packageName = getPackageNameFromModuleSpecifier(import_.specifier);
                 if (packageName && isInternalWorkspace(packageName)) {
-                    file.imports.external.add(packageName);
+                    file.imports.external.add({ ...import_, specifier: packageName });
                     const principal = getPrincipalByFilePath(specifierFilePath);
                     if (principal && !isGitIgnored(specifierFilePath)) {
                         principal.addNonEntryPath(specifierFilePath);
@@ -307,8 +304,14 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
-                const options = { cwd: dir, rootCwd: cwd, containingFilePath: filePath, dependencies, manifestScriptNames };
-                const inputs = _getInputsFromScripts(file.scripts, options);
+                const opts = {
+                    cwd: dir,
+                    rootCwd: options.cwd,
+                    containingFilePath: filePath,
+                    dependencies,
+                    manifestScriptNames,
+                };
+                const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
@@ -318,7 +321,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 }
             }
             const node = getOrCreateFileNode(graph, filePath);
-            file.imports.unresolved = _unresolved;
+            file.imports.unresolved = unresolvedImports;
             Object.assign(node, file);
             updateImportMap(node, file.imports.internal, graph);
             node.internalImportCache = file.imports.internal;
@@ -334,7 +337,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             streamer.cast('Running async compilers');
             await principal.runAsyncCompilers();
         }
-        streamer.cast('Analyzing source files', toRelative(principal.cwd));
+        streamer.cast('Analyzing source files', toRelative(principal.cwd, options.cwd));
         let size = principal.entryPaths.size;
         let round = 0;
         do {
@@ -350,16 +353,16 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         for (const filePath of principal.entryPaths)
             entryPaths.add(filePath);
         principal.reconcileCache(graph);
-        if (isIsolateWorkspaces || (isSkipLibs && !isWatch)) {
-            factory.deletePrincipal(principal);
+        if (options.isIsolateWorkspaces || (options.isSkipLibs && !options.isWatch)) {
+            factory.deletePrincipal(principal, options.cwd);
             principals[i] = undefined;
         }
         perfObserver.addMemoryMark(factory.getPrincipalCount());
     }
-    if (!isWatch && isSkipLibs && !isIsolateWorkspaces) {
+    if (!options.isWatch && options.isSkipLibs && !options.isIsolateWorkspaces) {
         for (const principal of principals) {
             if (principal)
-                factory.deletePrincipal(principal);
+                factory.deletePrincipal(principal, options.cwd);
         }
         principals.length = 0;
     }

package/dist/index.d.ts

@@ -1,14 +1,10 @@
-import type { CommandLineOptions } from './types/cli.js';
+import type { MainOptions } from './util/create-options.js';
 export type { RawConfiguration as KnipConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
-export declare const main: (unresolvedConfiguration: CommandLineOptions) => Promise<{
-    report: import("./types/issues.js").Report;
+export declare const main: (options: MainOptions) => Promise<{
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
-    rules: import("./types/issues.js").Rules;
     tagHints: Set<import("./types/issues.js").TagHint>;
     configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
-    isTreatConfigHintsAsErrors: boolean;
-    includedWorkspaces: import("./ConfigurationChief.js").Workspace[];
-    configFilePath: string | undefined;
+    includedWorkspaceDirs: string[];
 }>;

package/dist/index.js

@@ -11,57 +11,30 @@ import { build } from './graph/build.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
-export const main = async (unresolvedConfiguration) => {
-    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isFormat, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
-    debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
-    const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace });
-    const deputy = new DependencyDeputy({ isProduction, isStrict });
+export const main = async (options) => {
+    const { cwd } = options;
+    debugLogObject('*', 'Unresolved configuration', options);
+    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    const chief = new ConfigurationChief(options);
+    const deputy = new DependencyDeputy(options);
     const factory = new PrincipalFactory();
-    const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
+    const streamer = new ConsoleStreamer(options);
+    const fixer = new IssueFixer(options);
+    const collector = new IssueCollector(options);
     streamer.cast('Reading workspace configuration');
-    await chief.init();
-    const workspaces = chief.getWorkspaces();
-    const report = chief.getIncludedIssueTypes({
-        includedIssueTypes,
-        excludedIssueTypes,
-        isDependenciesShorthand,
-        isExportsShorthand,
-        isFilesShorthand,
-    });
-    const rules = chief.getRules();
-    const filters = chief.getFilters();
-    const finalTags = tags[0].length > 0 || tags[1].length > 0 ? tags : chief.getTags();
-    const fixer = new IssueFixer({ isEnabled: isFix, cwd, fixTypes, isRemoveFiles });
-    debugLogObject('*', 'Included issue types', report);
-    const isReportClassMembers = report.classMembers;
-    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
-    const collector = new IssueCollector({ cwd, rules, filters });
-    const o = () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors }));
+    const workspaces = await chief.getWorkspaces();
+    const isGitIgnored = await getGitIgnoredHandler(options);
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
-    debugLogObject('*', 'Included workspace configs', o);
-    const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
+    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
     const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
-        cacheLocation,
         chief,
         collector,
-        cwd,
         deputy,
         factory,
-        gitignore,
-        isCache,
-        isFixExports: fixer.isEnabled && fixer.isFixUnusedExports,
-        isFixTypes: fixer.isEnabled && fixer.isFixUnusedTypes,
         isGitIgnored,
-        isIsolateWorkspaces,
-        isProduction,
-        isSkipLibs,
-        isStrict,
-        isWatch,
-        report,
         streamer,
-        tags: finalTags,
-        tsConfigFile,
         workspaces,
+        options,
     });
     const reAnalyze = await analyze({
         analyzedFiles,
@@ -72,39 +45,30 @@ export const main = async (unresolvedConfiguration) => {
         factory,
         fixer,
         graph,
-        isFix,
-        isIncludeLibs,
-        isProduction,
-        report,
         streamer,
-        tags: finalTags,
         unreferencedFiles,
+        options,
     });
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    for (const hint of chief.getConfigurationHints())
-        collector.addConfigurationHint(hint);
-    if (isWatch) {
-        const isIgnored = (filePath) => filePath.startsWith(cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
-        const watchHandler = await getWatchHandler({
+    if (options.isWatch) {
+        const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
+        const watchHandler = await getWatchHandler(options, {
             analyzedFiles,
             analyzeSourceFile,
             chief,
             collector,
             analyze: reAnalyze,
-            cwd,
             factory,
             graph,
-            isDebug,
             isIgnored,
-            report,
             streamer,
             unreferencedFiles,
         });
         watch('.', { recursive: true }, watchHandler);
     }
-    if (isFix) {
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    if (options.isFix) {
         const touchedFiles = await fixer.fixIssues(issues);
-        if (isFormat) {
+        if (options.isFormat) {
             const report = await formatly(Array.from(touchedFiles), { cwd });
             if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
                 debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
@@ -114,17 +78,13 @@ export const main = async (unresolvedConfiguration) => {
             }
         }
     }
-    if (!isWatch)
+    if (!options.isWatch)
         streamer.clear();
     return {
-        report,
         issues,
         counters,
-        rules,
         tagHints,
         configurationHints,
-        isTreatConfigHintsAsErrors: chief.config.isTreatConfigHintsAsErrors,
-        includedWorkspaces: chief.includedWorkspaces,
-        configFilePath: chief.resolvedConfigFilePath,
+        includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
     };
 };

package/dist/plugins/angular/index.js

@@ -8,7 +8,6 @@ const enablers = ['@angular/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['angular.json'];
 const resolveConfig = async (config, options) => {
-    const { cwd, configFilePath } = options;
     if (!config?.projects)
         return [];
     const inputs = new Set();
@@ -22,7 +21,7 @@ const resolveConfig = async (config, options) => {
                 inputs.add(toDependency(packageName));
             if (opts) {
                 if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
-                    inputs.add(toConfig('typescript', opts.tsConfig, { containingFilePath: configFilePath }));
+                    inputs.add(toConfig('typescript', opts.tsConfig));
                 }
             }
             const defaultEntriesByOption = opts ? entriesByOption(opts) : new Map();
@@ -31,7 +30,7 @@ const resolveConfig = async (config, options) => {
             const isBuildTarget = targetName === BUILD_TARGET_NAME;
             const maybeExternal = (option) => option === 'polyfills';
             const toInput = (specifier, opts) => {
-                const normalizedPath = join(cwd, specifier);
+                const normalizedPath = join(options.cwd, specifier);
                 if (opts.maybeExternal && !isInternal(specifier) && !existsSync(normalizedPath)) {
                     return toDeferResolve(specifier);
                 }

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

@@ -0,0 +1,8 @@
+import type { IsPluginEnabled } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    entry: string[];
+};
+export default _default;