knip 5.63.0 → 5.64.0

package/dist/ConfigurationChief.js

@@ -1,29 +1,19 @@
 import path from 'node:path';
 import picomatch from 'picomatch';
-import { partitionCompilers } from './compilers/index.js';
-import { DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS, ROOT_WORKSPACE_NAME } from './constants.js';
-import { knipConfigurationSchema } from './schema/configuration.js';
+import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { pluginNames } from './types/PluginNames.js';
 import { arrayify, compact, partition } from './util/array.js';
-import parsedArgValues from './util/cli-arguments.js';
 import { createWorkspaceGraph } from './util/create-workspace-graph.js';
 import { ConfigurationError } from './util/errors.js';
-import { findFile, isDirectory, isFile, loadJSON } from './util/fs.js';
-import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
+import { isDirectory, isFile } from './util/fs.js';
 import { _dirGlob, removeProductionSuffix } from './util/glob.js';
 import { graphSequencer } from './util/graph-sequencer.js';
-import { defaultRules } from './util/issue-initializers.js';
-import { _load } from './util/loader.js';
 import mapWorkspaces from './util/map-workspaces.js';
-import { getKeysByValue } from './util/object.js';
-import { isAbsolute, join, relative } from './util/path.js';
+import { join, relative } from './util/path.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
-import { splitTags } from './util/tag.js';
-import { unwrapFunction } from './util/unwrap-function.js';
 import { byPathDepth } from './util/workspace.js';
-const { config: rawConfigArg } = parsedArgValues;
 const defaultBaseFilenamePattern = '{index,cli,main}';
 export const isDefaultPattern = (type, id) => {
     if (type === 'project')
@@ -40,31 +30,27 @@ const getDefaultWorkspaceConfig = (extensions = []) => {
 };
 const isPluginName = (name) => pluginNames.includes(name);
 const defaultConfig = {
-    rules: defaultRules,
-    include: [],
-    exclude: [],
     ignore: [],
     ignoreBinaries: [],
     ignoreDependencies: [],
     ignoreMembers: [],
-    ignoreExportsUsedInFile: false,
+    ignoreUnresolved: [],
     ignoreWorkspaces: [],
+    ignoreExportsUsedInFile: false,
     isIncludeEntryExports: false,
-    isTreatConfigHintsAsErrors: false,
     syncCompilers: new Map(),
     asyncCompilers: new Map(),
     rootPluginConfigs: {},
-    tags: [],
 };
 export class ConfigurationChief {
     cwd;
-    isProduction = false;
-    isStrict = false;
-    isIncludeEntryExports = false;
+    rawConfig;
+    isProduction;
+    isStrict;
+    isIncludeEntryExports;
     config;
     workspace;
-    manifestPath;
-    manifest;
+    workspaces;
     ignoredWorkspacePatterns = [];
     workspacePackages = new Map();
     workspacesByPkgName = new Map();
@@ -75,58 +61,26 @@ export class ConfigurationChief {
     availableWorkspaceDirs = [];
     workspaceGraph = new Map();
     includedWorkspaces = [];
-    resolvedConfigFilePath;
-    rawConfig;
-    parsedConfig;
-    constructor({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace }) {
-        this.cwd = cwd;
-        this.isProduction = isProduction;
-        this.isStrict = isStrict;
-        this.isIncludeEntryExports = isIncludeEntryExports;
-        this.config = defaultConfig;
-        this.workspace = workspace;
-    }
-    async init() {
-        const manifestPath = findFile(this.cwd, 'package.json');
-        const manifest = manifestPath && (await loadJSON(manifestPath));
-        if (!(manifestPath && manifest)) {
-            throw new ConfigurationError('Unable to find package.json');
-        }
-        this.manifestPath = manifestPath;
-        this.manifest = manifest;
-        const pnpmWorkspacesPath = findFile(this.cwd, 'pnpm-workspace.yaml');
-        const pnpmWorkspaces = pnpmWorkspacesPath && (await _load(pnpmWorkspacesPath));
-        if (this.manifest && pnpmWorkspaces) {
-            this.manifest.workspaces = pnpmWorkspaces;
-        }
-        for (const configPath of rawConfigArg ? [rawConfigArg] : KNIP_CONFIG_LOCATIONS) {
-            this.resolvedConfigFilePath = isAbsolute(configPath) ? configPath : findFile(this.cwd, configPath);
-            if (this.resolvedConfigFilePath)
-                break;
-        }
-        if (rawConfigArg && !this.resolvedConfigFilePath && !manifest.knip) {
-            throw new ConfigurationError(`Unable to find ${rawConfigArg} or package.json#knip`);
-        }
-        this.rawConfig = this.resolvedConfigFilePath
-            ? await this.loadResolvedConfigurationFile(this.resolvedConfigFilePath)
-            : manifest.knip;
-        if (manifest.knip)
-            this.resolvedConfigFilePath = manifestPath;
-        this.parsedConfig = this.rawConfig ? knipConfigurationSchema.parse(partitionCompilers(this.rawConfig)) : {};
-        this.config = this.normalize(this.parsedConfig);
-        await this.setWorkspaces();
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.isProduction = options.isProduction;
+        this.isStrict = options.isStrict;
+        this.isIncludeEntryExports = options.isIncludeEntryExports;
+        this.workspace = options.workspace;
+        this.workspaces = options.workspaces;
+        this.rawConfig = options.parsedConfig;
+        this.config = this.normalize(options.parsedConfig ?? {});
     }
     getConfigurationHints() {
         const hints = new Set();
-        const config = this.parsedConfig;
-        if (config) {
+        if (this.rawConfig) {
             if (this.workspacePackages.size > 1) {
-                const entry = arrayify(config.entry);
+                const entry = arrayify(this.rawConfig.entry);
                 if (entry.length > 0) {
                     const identifier = `[${entry[0]}${entry.length > 1 ? `, ${ELLIPSIS}` : ''}]`;
                     hints.add({ type: 'entry-top-level', identifier });
                 }
-                const project = arrayify(config.project);
+                const project = arrayify(this.rawConfig.project);
                 if (project.length > 0) {
                     const identifier = `[${project[0]}${project.length > 1 ? `, ${ELLIPSIS}` : ''}]`;
                     hints.add({ type: 'project-top-level', identifier });
@@ -135,35 +89,15 @@ export class ConfigurationChief {
         }
         return hints;
     }
-    async loadResolvedConfigurationFile(configPath) {
-        const loadedValue = await _load(configPath);
-        try {
-            return await unwrapFunction(loadedValue);
-        }
-        catch (_error) {
-            throw new ConfigurationError(`Error running the function from ${configPath}`);
-        }
-    }
-    getRules() {
-        return this.config.rules;
-    }
-    getFilters() {
-        if (this.workspaceGraph && this.workspace)
-            return { dir: join(this.cwd, this.workspace) };
-        return {};
-    }
     normalize(rawConfig) {
-        const rules = { ...defaultRules, ...rawConfig.rules };
-        const include = rawConfig.include ?? defaultConfig.include;
-        const exclude = rawConfig.exclude ?? defaultConfig.exclude;
         const ignore = arrayify(rawConfig.ignore ?? defaultConfig.ignore);
         const ignoreBinaries = rawConfig.ignoreBinaries ?? [];
         const ignoreDependencies = rawConfig.ignoreDependencies ?? [];
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
+        const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
-        const isTreatConfigHintsAsErrors = rawConfig.treatConfigHintsAsErrors ?? defaultConfig.isTreatConfigHintsAsErrors;
         const { syncCompilers, asyncCompilers } = rawConfig;
         const rootPluginConfigs = {};
         for (const [pluginName, pluginConfig] of Object.entries(rawConfig)) {
@@ -172,24 +106,20 @@ export class ConfigurationChief {
             }
         }
         return {
-            rules,
-            include,
-            exclude,
             ignore,
             ignoreBinaries,
             ignoreDependencies,
             ignoreMembers,
+            ignoreUnresolved,
             ignoreExportsUsedInFile,
             ignoreWorkspaces,
             isIncludeEntryExports,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
             rootPluginConfigs,
-            tags: rawConfig.tags ?? [],
-            isTreatConfigHintsAsErrors,
         };
     }
-    async setWorkspaces() {
+    async getWorkspaces() {
         this.ignoredWorkspacePatterns = this.getIgnoredWorkspacePatterns();
         this.additionalWorkspaceNames = await this.getAdditionalWorkspaceNames();
         const workspaceNames = compact([...this.getListedWorkspaces(), ...this.additionalWorkspaceNames]);
@@ -207,14 +137,12 @@ export class ConfigurationChief {
             this.workspacesByPkgName.set(workspace.pkgName, workspace);
             this.workspacesByName.set(workspace.name, workspace);
         }
+        const sorted = graphSequencer(this.workspaceGraph, this.includedWorkspaces.map(workspace => workspace.dir));
+        const [root, rest] = partition(sorted.chunks.flat(), dir => dir === this.cwd);
+        return [...root, ...rest.reverse()].map(dir => this.includedWorkspaces.find(w => w.dir === dir));
     }
     getListedWorkspaces() {
-        const workspaces = this.manifest?.workspaces
-            ? Array.isArray(this.manifest.workspaces)
-                ? this.manifest.workspaces
-                : (this.manifest.workspaces.packages ?? [])
-            : [];
-        return workspaces.map(pattern => pattern.replace(/(?<=!?)\.\//, ''));
+        return this.workspaces.map(pattern => pattern.replace(/(?<=!?)\.\//, ''));
     }
     getIgnoredWorkspaces() {
         const ignoreWorkspaces = this.config.ignoreWorkspaces;
@@ -309,7 +237,7 @@ export class ConfigurationChief {
             const manifestPath = pkg?.manifestPath ?? join(dir, 'package.json');
             const manifestStr = pkg?.manifestStr ?? '';
             const workspaceConfig = this.getWorkspaceConfig(name);
-            const ignoreMembers = arrayify(workspaceConfig.ignoreMembers).map(toRegexOrString);
+            const ignoreMembers = workspaceConfig.ignoreMembers?.map(toRegexOrString) ?? [];
             return {
                 name,
                 pkgName,
@@ -325,11 +253,6 @@ export class ConfigurationChief {
     getManifestForWorkspace(name) {
         return this.workspacePackages.get(name)?.manifest;
     }
-    getWorkspaces() {
-        const sorted = graphSequencer(this.workspaceGraph, this.includedWorkspaces.map(workspace => workspace.dir));
-        const [root, rest] = partition(sorted.chunks.flat(), dir => dir === this.cwd);
-        return [...root, ...rest.reverse()].map(dir => this.includedWorkspaces.find(w => w.dir === dir));
-    }
     getDescendentWorkspaces(name) {
         return this.availableWorkspaceNames
             .filter(workspaceName => workspaceName !== name)
@@ -366,9 +289,9 @@ export class ConfigurationChief {
     }
     getIgnores(workspaceName) {
         const workspaceConfig = this.getWorkspaceConfig(workspaceName);
-        const ignoreBinaries = arrayify(workspaceConfig.ignoreBinaries);
-        const ignoreDependencies = arrayify(workspaceConfig.ignoreDependencies);
-        const ignoreUnresolved = arrayify(workspaceConfig.ignoreUnresolved);
+        const ignoreBinaries = workspaceConfig.ignoreBinaries ?? [];
+        const ignoreDependencies = workspaceConfig.ignoreDependencies ?? [];
+        const ignoreUnresolved = workspaceConfig.ignoreUnresolved ?? [];
         if (workspaceName === ROOT_WORKSPACE_NAME) {
             const { ignoreBinaries: rootIgnoreBinaries, ignoreDependencies: rootIgnoreDependencies, ignoreUnresolved: rootIgnoreUnresolved, } = this.rawConfig ?? {};
             return {
@@ -399,15 +322,6 @@ export class ConfigurationChief {
         }
         return { entry, project, paths, ignore, isIncludeEntryExports, ...plugins };
     }
-    getIncludedIssueTypes(cliArgs) {
-        const excludesFromRules = getKeysByValue(this.config.rules, 'off');
-        const config = {
-            include: this.config.include ?? [],
-            exclude: [...excludesFromRules, ...this.config.exclude],
-            isProduction: this.isProduction,
-        };
-        return getIncludedIssueTypes(cliArgs, config);
-    }
     findWorkspaceByFilePath(filePath) {
         const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(`${workspaceDir}/`));
         return this.includedWorkspaces.find(workspace => workspace.dir === workspaceDir);
@@ -422,7 +336,4 @@ export class ConfigurationChief {
             return !isDirectory(dir) || isFile(join(dir, 'package.json'));
         });
     }
-    getTags() {
-        return splitTags(this.config.tags);
-    }
 }

package/dist/ConsoleStreamer.d.ts

@@ -1,9 +1,8 @@
+import type { MainOptions } from './util/create-options.js';
 export declare class ConsoleStreamer {
     isEnabled: boolean;
     private lines;
-    constructor({ isEnabled }: {
-        isEnabled?: boolean | undefined;
-    });
+    constructor(options: MainOptions);
     private clearLines;
     private resetLines;
     private update;

package/dist/ConsoleStreamer.js

@@ -1,8 +1,8 @@
 export class ConsoleStreamer {
     isEnabled = false;
     lines = 0;
-    constructor({ isEnabled = false }) {
-        this.isEnabled = isEnabled;
+    constructor(options) {
+        this.isEnabled = options.isShowProgress;
     }
     clearLines(count) {
         if (count > 0) {

package/dist/DependencyDeputy.d.ts

@@ -2,10 +2,7 @@ import type { Workspace } from './ConfigurationChief.js';
 import type { ConfigurationHints, Counters, Issue, Issues, SymbolIssueType } from './types/issues.js';
 import type { PackageJson } from './types/package-json.js';
 import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.js';
-type Options = {
-    isProduction: boolean;
-    isStrict: boolean;
-};
+import type { MainOptions } from './util/create-options.js';
 export declare class DependencyDeputy {
     isProduction: boolean;
     isStrict: boolean;
@@ -15,7 +12,7 @@ export declare class DependencyDeputy {
     hostDependencies: Map<string, HostDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
-    constructor({ isProduction, isStrict }: Options);
+    constructor({ isProduction, isStrict }: MainOptions);
     addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies: id, ignoreBinaries: ib, ignoreUnresolved: iu, }: {
         name: string;
         cwd: string;
@@ -77,4 +74,3 @@ export declare class DependencyDeputy {
     addIgnoredDependencies(workspaceName: string, identifier: string): void;
     addIgnoredBinaries(workspaceName: string, identifier: string): void;
 }
-export {};

package/dist/DependencyDeputy.js

@@ -4,6 +4,7 @@ import { DT_SCOPE, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIM
 import { getDependencyMetaData } from './manifest/index.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
 import { findMatch, toRegexOrString } from './util/regex.js';
+const filterIsProduction = (id, isProduction) => typeof id === 'string' ? (isProduction || !id.endsWith('!') ? id.replace(/!$/, '') : []) : id;
 export class DependencyDeputy {
     isProduction;
     isStrict;
@@ -46,8 +47,8 @@ export class DependencyDeputy {
         this.setHostDependencies(name, hostDependencies);
         this.setInstalledBinaries(name, installedBinaries);
         this.setHasTypesIncluded(name, hasTypesIncluded);
-        const ignoreDependencies = id.map(toRegexOrString);
-        const ignoreBinaries = ib.map(toRegexOrString);
+        const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
+        const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
         const ignoreUnresolved = iu.map(toRegexOrString);
         this._manifests.set(name, {
             workspaceDir: dir,

package/dist/IssueCollector.d.ts

@@ -1,16 +1,9 @@
-import type { ConfigurationHint, Issue, Rules, TagHint } from './types/issues.js';
-type Filters = Partial<{
-    dir: string;
-}>;
-type IssueCollectorOptions = {
-    cwd: string;
-    rules: Rules;
-    filters: Filters;
-};
+import type { ConfigurationHint, Issue, TagHint } from './types/issues.js';
+import type { MainOptions } from './util/create-options.js';
 export declare class IssueCollector {
     private cwd;
     private rules;
-    private filters;
+    private filter;
     private issues;
     private counters;
     private referencedFiles;
@@ -18,7 +11,7 @@ export declare class IssueCollector {
     private tagHints;
     private ignorePatterns;
     private isMatch;
-    constructor({ cwd, rules, filters }: IssueCollectorOptions);
+    constructor(options: MainOptions);
     addIgnorePatterns(patterns: string[]): void;
     addFileCounts({ processed, unused }: {
         processed: number;
@@ -36,4 +29,3 @@ export declare class IssueCollector {
         configurationHints: Set<ConfigurationHint>;
     };
 }
-export {};

package/dist/IssueCollector.js

@@ -1,13 +1,13 @@
 import picomatch from 'picomatch';
 import { timerify } from './util/Performance.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
-import { relative } from './util/path.js';
+import { join, relative } from './util/path.js';
 const hasConfigurationHint = (hints, hint) => Array.from(hints).some(item => item.identifier === hint.identifier && item.type === hint.type && item.workspaceName === hint.workspaceName);
 const isMatch = timerify(picomatch.isMatch, 'isMatch');
 export class IssueCollector {
     cwd;
     rules;
-    filters;
+    filter;
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
@@ -15,10 +15,10 @@ export class IssueCollector {
     tagHints = new Set();
     ignorePatterns = new Set();
     isMatch;
-    constructor({ cwd, rules, filters }) {
-        this.cwd = cwd;
-        this.rules = rules;
-        this.filters = filters;
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.rules = options.rules;
+        this.filter = options.workspace ? join(options.cwd, options.workspace) : undefined;
         this.isMatch = () => false;
     }
     addIgnorePatterns(patterns) {
@@ -33,21 +33,21 @@ export class IssueCollector {
     }
     addFilesIssues(filePaths) {
         for (const filePath of filePaths) {
-            if (this.filters.dir && !filePath.startsWith(`${this.filters.dir}/`))
+            if (this.filter && !filePath.startsWith(`${this.filter}/`))
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
             if (this.isMatch(filePath))
                 continue;
             this.issues.files.add(filePath);
-            const symbol = relative(filePath);
+            const symbol = relative(this.cwd, filePath);
             this.issues._files[symbol] = [{ type: 'files', filePath, symbol, severity: this.rules.files }];
             this.counters.files++;
             this.counters.processed++;
         }
     }
     addIssue(issue) {
-        if (this.filters.dir && !issue.filePath.startsWith(`${this.filters.dir}/`))
+        if (this.filter && !issue.filePath.startsWith(`${this.filter}/`))
             return;
         if (this.isMatch(issue.filePath))
             return;

package/dist/IssueFixer.d.ts

@@ -1,21 +1,11 @@
 import type { Fix, Fixes } from './types/exports.js';
 import type { Issues } from './types/issues.js';
-interface Fixer {
-    isEnabled: boolean;
-    cwd: string;
-    fixTypes: string[];
-    isRemoveFiles: boolean;
-}
+import type { MainOptions } from './util/create-options.js';
 export declare class IssueFixer {
-    isEnabled: boolean;
-    cwd: string;
-    isFixFiles: boolean;
-    isFixDependencies: boolean;
-    isFixUnusedTypes: boolean;
-    isFixUnusedExports: boolean;
+    options: MainOptions;
     unusedTypeNodes: Map<string, Set<Fix>>;
     unusedExportNodes: Map<string, Set<Fix>>;
-    constructor({ isEnabled, cwd, fixTypes, isRemoveFiles }: Fixer);
+    constructor(options: MainOptions);
     addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
     addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
     fixIssues(issues: Issues): Promise<Set<string>>;
@@ -24,4 +14,3 @@ export declare class IssueFixer {
     private removeUnusedExports;
     private removeUnusedDependencies;
 }
-export {};

package/dist/IssueFixer.js

@@ -3,21 +3,11 @@ import { load, save } from './util/package-json.js';
 import { join, relative } from './util/path.js';
 import { removeExport } from './util/remove-export.js';
 export class IssueFixer {
-    isEnabled = false;
-    cwd = process.cwd();
-    isFixFiles = true;
-    isFixDependencies = true;
-    isFixUnusedTypes = true;
-    isFixUnusedExports = true;
+    options;
     unusedTypeNodes = new Map();
     unusedExportNodes = new Map();
-    constructor({ isEnabled, cwd, fixTypes = [], isRemoveFiles }) {
-        this.isEnabled = isEnabled;
-        this.cwd = cwd;
-        this.isFixFiles = isRemoveFiles && (fixTypes.length === 0 || fixTypes.includes('files'));
-        this.isFixDependencies = fixTypes.length === 0 || fixTypes.includes('dependencies');
-        this.isFixUnusedTypes = fixTypes.length === 0 || fixTypes.includes('types');
-        this.isFixUnusedExports = fixTypes.length === 0 || fixTypes.includes('exports');
+    constructor(options) {
+        this.options = options;
     }
     addUnusedTypeNode(filePath, fixes) {
         if (!fixes || fixes.length === 0)
@@ -47,10 +37,10 @@ export class IssueFixer {
         return touchedFiles;
     }
     markExportFixed(issues, filePath) {
-        const relPath = relative(filePath);
+        const relPath = relative(this.options.cwd, filePath);
         const types = [
-            ...(this.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
-            ...(this.isFixUnusedExports ? ['exports', 'nsExports'] : []),
+            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
+            ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
         ];
         for (const type of types) {
             for (const id in issues[type][relPath]) {
@@ -59,7 +49,7 @@ export class IssueFixer {
         }
     }
     async removeUnusedFiles(issues) {
-        if (!this.isFixFiles)
+        if (!this.options.isFixFiles)
             return;
         for (const issue of Object.values(issues._files).flatMap(Object.values)) {
             await rm(issue.filePath);
@@ -70,9 +60,11 @@ export class IssueFixer {
         const touchedFiles = new Set();
         const filePaths = new Set([...this.unusedTypeNodes.keys(), ...this.unusedExportNodes.keys()]);
         for (const filePath of filePaths) {
-            const types = (this.isFixUnusedTypes && this.unusedTypeNodes.get(filePath)) || [];
-            const exports = (this.isFixUnusedExports && this.unusedExportNodes.get(filePath)) || [];
-            const exportPositions = [...types, ...exports].filter(fix => fix !== undefined).sort((a, b) => b[0] - a[0]);
+            const types = (this.options.isFixUnusedTypes && this.unusedTypeNodes.get(filePath)) || [];
+            const exports = (this.options.isFixUnusedExports && this.unusedExportNodes.get(filePath)) || [];
+            const exportPositions = [...types, ...exports]
+                .filter((fix) => fix !== undefined)
+                .sort((a, b) => b[0] - a[0]);
             if (exportPositions.length > 0) {
                 const sourceFileText = exportPositions.reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(filePath, 'utf-8'));
                 await writeFile(filePath, sourceFileText);
@@ -84,11 +76,11 @@ export class IssueFixer {
     }
     async removeUnusedDependencies(issues) {
         const touchedFiles = new Set();
-        if (!this.isFixDependencies)
+        if (!this.options.isFixDependencies)
             return touchedFiles;
         const filePaths = new Set([...Object.keys(issues.dependencies), ...Object.keys(issues.devDependencies)]);
         for (const filePath of filePaths) {
-            const absFilePath = join(this.cwd, filePath);
+            const absFilePath = join(this.options.cwd, filePath);
             const pkg = await load(absFilePath);
             if (filePath in issues.dependencies) {
                 for (const dependency of Object.keys(issues.dependencies[filePath])) {

package/dist/PrincipalFactory.d.ts

@@ -1,13 +1,14 @@
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { PrincipalOptions } from './types/project.js';
+import type { MainOptions } from './util/create-options.js';
 export declare class PrincipalFactory {
     private principals;
     getPrincipalCount(): number;
-    createPrincipal(options: PrincipalOptions): ProjectPrincipal;
+    createPrincipal(options: MainOptions, opts: PrincipalOptions): ProjectPrincipal;
     private findReusablePrincipal;
     private linkPrincipal;
     private addNewPrincipal;
     getPrincipals(): ProjectPrincipal[];
     getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
-    deletePrincipal(principal: ProjectPrincipal): void;
+    deletePrincipal(principal: ProjectPrincipal, cwd: string): void;
 }

package/dist/PrincipalFactory.js

@@ -7,18 +7,18 @@ export class PrincipalFactory {
     getPrincipalCount() {
         return this.principals.size;
     }
-    createPrincipal(options) {
-        const { cwd, compilerOptions, isFile, pkgName, isIsolateWorkspaces, compilers } = options;
+    createPrincipal(options, opts) {
+        const { dir, compilerOptions, isFile, pkgName, compilers } = opts;
         if (isFile && compilerOptions.module !== ts.ModuleKind.CommonJS)
             compilerOptions.moduleResolution ??= ts.ModuleResolutionKind.Bundler;
-        if (!isIsolateWorkspaces) {
+        if (!options.isIsolateWorkspaces) {
             const principal = this.findReusablePrincipal(compilerOptions);
             if (principal) {
-                this.linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers);
+                this.linkPrincipal(principal, dir, compilerOptions, pkgName, compilers);
                 return principal.principal;
             }
         }
-        return this.addNewPrincipal(options);
+        return this.addNewPrincipal(options, opts);
     }
     findReusablePrincipal(compilerOptions) {
         const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
@@ -43,11 +43,11 @@ export class PrincipalFactory {
         principal.wsDirs.add(cwd);
         principal.pkgNames.add(pkgName);
     }
-    addNewPrincipal(options) {
-        const { cwd, compilerOptions, pkgName } = options;
+    addNewPrincipal(options, opts) {
+        const { dir, compilerOptions, pkgName } = opts;
         const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
-        const principal = new ProjectPrincipal(options);
-        this.principals.add({ principal, wsDirs: new Set([cwd]), pathKeys, pkgNames: new Set([pkgName]) });
+        const principal = new ProjectPrincipal(options, opts);
+        this.principals.add({ principal, wsDirs: new Set([dir]), pathKeys, pkgNames: new Set([pkgName]) });
         return principal;
     }
     getPrincipals() {
@@ -56,10 +56,10 @@ export class PrincipalFactory {
     getPrincipalByPackageName(packageName) {
         return Array.from(this.principals).find(principal => principal.pkgNames.has(packageName))?.principal;
     }
-    deletePrincipal(principal) {
+    deletePrincipal(principal, cwd) {
         const p = Array.from(this.principals).find(p => p.principal === principal);
         if (p) {
-            debugLog('*', `Deleting principal at ${[...p.wsDirs].map(cwd => toRelative(cwd) || '.')} (${[...p.pkgNames]})`);
+            debugLog('*', `Deleting principal at ${[...p.wsDirs].map(dir => toRelative(dir, cwd) || '.')} (${[...p.pkgNames]})`);
             this.principals.delete(p);
         }
     }

package/dist/ProjectPrincipal.d.ts

@@ -1,11 +1,12 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
-import type { GetImportsAndExportsOptions } from './types/config.js';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from './types/config.js';
 import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { Paths, PrincipalOptions } from './types/project.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
+import type { MainOptions } from './util/create-options.js';
 import type { ToSourceFilePath } from './util/to-source-path.js';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
@@ -31,7 +32,7 @@ export declare class ProjectPrincipal {
     };
     findReferences?: ts.LanguageService['findReferences'];
     getImplementationAtPosition?: ts.LanguageService['getImplementationAtPosition'];
-    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, isProduction, }: PrincipalOptions);
+    constructor(options: MainOptions, { compilerOptions, compilers, pkgName, toSourceFilePath }: PrincipalOptions);
     init(): void;
     addPaths(paths: Paths, basePath: string): void;
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
@@ -51,7 +52,7 @@ export declare class ProjectPrincipal {
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>): FileNode;
+    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile): FileNode;
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;