knip 0.4.0 → 0.4.1

package/README.md

@@ -1,7 +1,7 @@
 # ✂️ Knip
 
-Knip scans your JavaScript and TypeScript projects for **unused files, dependencies and exports**. Things that should be
-eliminated. Less code means better performance and less to maintain, important for both UX and DX!
+Knip scans your JavaScript and TypeScript projects for **unused files, dependencies and exports**: things that can be
+removed! Less code means better performance and less to maintain, important for both UX and DX!
 
 For comparison, ESLint finds unused variables inside files in isolation, but this will not be flagged:
 
@@ -142,7 +142,7 @@ As always, make sure to backup files or use Git before deleting files or making
 
 The default configuration for Knip is very strict and targets production code. For best results, it is recommended to
 exclude files such as tests from the project files. Here's why: when including tests and other non-production files,
-they may prevent production files from being reported as unused.
+they may import production files, which will prevent them from being reported as unused.
 
 Excluding non-production files from the `projectFiles` allows Knip to understand what production code can be removed
 (including dependent files!).
@@ -162,8 +162,7 @@ and add `dev: true` to a file named such as `knip.dev.json`:
 }
 ```
 
-Use `-c knip.dev.json` and unused files and exports for the combined set of files as configured in `entryFiles` will be
-reported.
+Now use `-c knip.dev.json` to find unused files and exports for the combined set of files as configured in `entryFiles`.
 
 An alternative way to store `dev` configuration is in this example `package.json`:
 
@@ -192,7 +191,7 @@ This way, the `--dev` flag will use the `dev` options (and also add `devDependen
 
 #### Separate packages
 
-In repos with multiple (published) packages, the `--cwd` option comes in handy. With similar package structures, the
+In repos with multiple (published) packages, the `--dir` option comes in handy. With similar package structures, the
 packages can be configured using globs:
 
 ```json
@@ -209,8 +208,8 @@ Packages can also be explicitly configured per package directory.
 To scan the packages separately, using the first match from the configuration file:
 
 ```
-knip --cwd packages/client
-knip --cwd packages/services
+knip --dir packages/client
+knip --dir packages/services
 ```
 
 #### Connected projects
@@ -296,16 +295,48 @@ src/components/Registration.tsx: Registration, default
 src/components/Products.tsx: ProductsList, default
 ```
 
-## Why Yet Another unused file/export finder?
-
-There are some fine modules available in the same category:
-
-- [unimported](https://github.com/smeijer/unimported)
-- [ts-unused-exports](https://github.com/pzavolinsky/ts-unused-exports)
-- [no-unused-export](https://github.com/plantain-00/no-unused-export)
-- [ts-prune](https://github.com/nadeesha/ts-prune)
-- [find-unused-exports](https://github.com/jaydenseric/find-unused-exports)
-
-However, the results where not always accurate, and none of them tick my boxes to find both unused files and exports. Or
-let me configure entry files and scope the project files for clean results. Especially for larger projects this kind of
-configuration is necessary. That's why I took another stab at it.
+## Why Yet Another unused file/dependency/export finder?
+
+There are already some great packages available. Getting good results when finding unused files, dependencies and
+exports is not trivial. Repositories don't seem to get any smaller and with the rise of monorepos even more so. Tools
+like this need to analyze potentially many and/or large files, which is memory and time-consuming. Although I normally
+try to stick to the Unix philosophy, here I believe it's efficient to merge these issue reports into a single tool. When
+building a dependency graph of the project, an abstract syntax tree for each file, and traversing all of this, why not
+collect the various issues in one go?
+
+## Comparison
+
+This table is a work in progress, but here's a first impression. Based on their docs (please report any mistakes):
+
+| Feature                     |  **knip**  | [depcheck][1] | [unimported][2] | [ts-unused-exports][3] | [ts-prune][4] | [find-unused-exports][5] |
+| --------------------------- | :--------: | :-----------: | :-------------: | :--------------------: | :-----------: | :----------------------: |
+| Unused files                |     ✅     |       -       |       ✅        |           -            |       -       |            -             |
+| Unused dependencies         |     ✅     |      ✅       |       ✅        |           -            |       -       |            -             |
+| Unlisted dependencies       |     ✅     |      ✅       |       ✅        |           -            |       -       |            -             |
+| Custom dependency resolvers | ❌ [#7][6] |      ✅       |     ❌ (1)      |           -            |       -       |            -             |
+| Unused exports              |     ✅     |       -       |        -        |           ✅           |      ✅       |            ✅            |
+| Duplicate exports           |     ✅     |       -       |        -        |           ❌           |      ❌       |            ❌            |
+| Search namespaces           |     ✅     |       -       |        -        |           ✅           |      ❌       |            ❌            |
+| Custom reporters            |     ✅     |       -       |        -        |           -            |       -       |            -             |
+| Pure JavaScript/ESM         |     ✅     |      ✅       |       ✅        |           -            |       -       |            ✅            |
+| Configure entry files       |     ✅     |      ❌       |       ✅        |           ❌           |      ❌       |            ❌            |
+| Support monorepo            |   🟠 (2)   |       -       |        -        |           -            |       -       |            -             |
+| ESLint plugin available     |     -      |       -       |        -        |           ✅           |       -       |            -             |
+
+✅ = Supported, ❌ = Not supported, - = Out of scope
+
+1. unimported is strict and works based on production files and `dependencies`, so does not have custom dependency
+   resolvers which are usually only needed for `devDependencies`.
+2. knip wants to [support monorepos](#monorepos) properly, the first steps in this direction are implemented.
+
+## Knip?!
+
+Knip is Dutch for a "cut". A Dutch expression is "to be ge**knip**t for something", which means to be perfectly suited
+for the job. I'm motivated to make knip perfectly suited for the job of cutting projects to perfection! ✂️
+
+[1]: https://github.com/depcheck/depcheck
+[2]: https://github.com/smeijer/unimported
+[3]: https://github.com/pzavolinsky/ts-unused-exports
+[4]: https://github.com/nadeesha/ts-prune
+[5]: https://github.com/jaydenseric/find-unused-exports
+[6]: https://github.com/webpro/knip/issues/7

package/dist/cli.js

@@ -6,14 +6,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
-const typescript_1 = __importDefault(require("typescript"));
+const _1 = require(".");
 const help_1 = require("./help");
-const config_1 = require("./util/config");
-const fs_1 = require("./util/fs");
-const ignore_1 = require("./util/ignore");
 const reporters_1 = __importDefault(require("./reporters"));
-const _1 = require(".");
-const { values: { help, dir, config: configFilePath = 'knip.json', tsConfig: tsConfigFilePath, include = [], exclude = [], dev: isDev = false, 'no-progress': noProgress = false, ignore = [], 'no-gitignore': isNoGitIgnore = false, reporter = 'symbols', jsdoc = [], 'max-issues': maxIssues = '0', }, } = (0, node_util_1.parseArgs)({
+const { values: { help, dir, config: configFilePath = 'knip.json', tsConfig: tsConfigFilePath, include = [], exclude = [], ignore = [], 'no-gitignore': isNoGitIgnore = false, dev: isDev = false, 'no-progress': noProgress = false, reporter = 'symbols', 'max-issues': maxIssues = '0', jsdoc: jsDoc = [], }, } = (0, node_util_1.parseArgs)({
     options: {
         help: { type: 'boolean' },
         config: { type: 'string', short: 'c' },
@@ -21,11 +17,11 @@ const { values: { help, dir, config: configFilePath = 'knip.json', tsConfig: tsC
         dir: { type: 'string' },
         include: { type: 'string', multiple: true },
         exclude: { type: 'string', multiple: true },
-        dev: { type: 'boolean' },
-        'max-issues': { type: 'string' },
         ignore: { type: 'string', multiple: true },
         'no-gitignore': { type: 'boolean' },
+        dev: { type: 'boolean' },
         'no-progress': { type: 'boolean' },
+        'max-issues': { type: 'string' },
         reporter: { type: 'string' },
         jsdoc: { type: 'string', multiple: true },
     },
@@ -38,69 +34,37 @@ const cwd = process.cwd();
 const workingDir = dir ? node_path_1.default.resolve(dir) : cwd;
 const isShowProgress = noProgress === false ? process.stdout.isTTY && typeof process.stdout.cursorTo === 'function' : !noProgress;
 const printReport = reporter in reporters_1.default ? reporters_1.default[reporter] : require(node_path_1.default.join(workingDir, reporter));
-const main = async () => {
-    const localConfigurationPath = await (0, fs_1.findFile)(workingDir, configFilePath);
-    const manifestPath = await (0, fs_1.findFile)(workingDir, 'package.json');
-    const localConfiguration = localConfigurationPath && require(localConfigurationPath);
-    const manifest = manifestPath && require(manifestPath);
-    if (!localConfigurationPath && !manifest.knip) {
-        const location = workingDir === cwd ? 'current directory' : `${node_path_1.default.relative(cwd, workingDir)} or up.`;
-        console.error(`Unable to find ${configFilePath} or package.json#knip in ${location}\n`);
-        (0, help_1.printHelp)();
-        process.exit(1);
-    }
-    const resolvedConfig = (0, config_1.resolveConfig)(manifest.knip ?? localConfiguration, { workingDir: dir, isDev });
-    if (!resolvedConfig) {
-        (0, help_1.printHelp)();
-        process.exit(1);
-    }
-    const report = (0, config_1.resolveIncludedIssueGroups)(include, exclude, resolvedConfig);
-    let tsConfigPaths = [];
-    const tsConfigPath = await (0, fs_1.findFile)(workingDir, tsConfigFilePath ?? 'tsconfig.json');
-    if (tsConfigFilePath && !tsConfigPath) {
-        console.error(`Unable to find ${tsConfigFilePath}\n`);
-        (0, help_1.printHelp)();
-        process.exit(1);
+const run = async () => {
+    try {
+        const { report, issues, counters } = await (0, _1.main)({
+            cwd,
+            workingDir,
+            configFilePath,
+            tsConfigFilePath,
+            include,
+            exclude,
+            ignore,
+            gitignore: !isNoGitIgnore,
+            isDev,
+            isShowProgress,
+            jsDoc,
+        });
+        printReport({ report, issues, workingDir, isDev });
+        const reportGroup = report.files ? 'files' : Object.keys(report).find(key => report[key]);
+        const counterGroup = reportGroup === 'unlisted' ? 'unresolved' : reportGroup;
+        if (counterGroup) {
+            const count = counters[counterGroup];
+            if (count > Number(maxIssues))
+                process.exit(count);
+        }
     }
-    if (tsConfigPath) {
-        const tsConfig = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
-        tsConfigPaths = tsConfig.config.compilerOptions?.paths
-            ? Object.keys(tsConfig.config.compilerOptions.paths).map(p => p.replace(/\*/g, '**'))
-            : [];
-        if (tsConfig.error) {
-            console.error(`An error occured when reading ${node_path_1.default.relative(cwd, tsConfigPath)}.\n`);
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(error.message + '\n');
             (0, help_1.printHelp)();
             process.exit(1);
         }
-    }
-    const ignorePatterns = ignore.map(ignore_1.convertPattern);
-    if (!isNoGitIgnore) {
-        const patterns = await (0, ignore_1.readIgnorePatterns)(cwd, workingDir);
-        patterns.forEach(pattern => ignorePatterns.push(pattern));
-    }
-    const config = {
-        workingDir,
-        report,
-        dependencies: Object.keys(manifest.dependencies ?? {}),
-        devDependencies: Object.keys(manifest.devDependencies ?? {}),
-        isDev: typeof resolvedConfig.dev === 'boolean' ? resolvedConfig.dev : isDev,
-        tsConfigFilePath,
-        tsConfigPaths,
-        ignorePatterns,
-        isShowProgress,
-        jsDocOptions: {
-            isReadPublicTag: jsdoc.includes('public'),
-        },
-        ...resolvedConfig,
-    };
-    const { issues, counters } = await (0, _1.run)(config);
-    printReport({ issues, workingDir, config });
-    const reportGroup = report.files ? 'files' : Object.keys(report).find(key => report[key]);
-    const counterGroup = reportGroup === 'unlisted' ? 'unresolved' : reportGroup;
-    if (counterGroup) {
-        const count = counters[counterGroup];
-        if (count > Number(maxIssues))
-            process.exit(count);
+        throw error;
     }
 };
-main();
+run();

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import type { Configuration, Issues } from './types';
-export declare function run(configuration: Configuration): Promise<{
-    issues: Issues;
+import type { UnresolvedConfiguration } from './types';
+export declare const main: (options: UnresolvedConfiguration) => Promise<{
+    report: import("./types").Report;
+    issues: import("./types").Issues;
     counters: {
         files: number;
         dependencies: number;

package/dist/index.js

@@ -3,196 +3,81 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
+exports.main = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const ts_morph_1 = require("ts-morph");
-const ts_morph_helpers_1 = require("ts-morph-helpers");
+const typescript_1 = __importDefault(require("typescript"));
+const config_1 = require("./util/config");
+const fs_1 = require("./util/fs");
+const path_1 = require("./util/path");
 const project_1 = require("./util/project");
-const type_1 = require("./util/type");
-const dependencies_1 = require("./util/dependencies");
-const log_1 = require("./log");
-const lineRewriter = new log_1.LineRewriter();
-async function run(configuration) {
-    const { workingDir, isShowProgress, report, isDev, jsDocOptions } = configuration;
-    const { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies } = (0, dependencies_1.getDependencyAnalyzer)(configuration);
-    const production = await (0, project_1.createProject)(configuration, configuration.entryFiles);
+const runner_1 = require("./runner");
+const main = async (options) => {
+    const { cwd, workingDir, configFilePath = 'knip.json', tsConfigFilePath, include, exclude, ignore, gitignore, isDev, isShowProgress, jsDoc, } = options;
+    const localConfigurationPath = configFilePath && (await (0, fs_1.findFile)(workingDir, configFilePath));
+    const manifestPath = await (0, fs_1.findFile)(workingDir, 'package.json');
+    const localConfiguration = localConfigurationPath && require(localConfigurationPath);
+    const manifest = manifestPath && require(manifestPath);
+    if (!localConfigurationPath && !manifest.knip) {
+        const location = workingDir === cwd ? 'current directory' : `${node_path_1.default.relative(cwd, workingDir)} or up.`;
+        throw new Error(`Unable to find ${configFilePath} or package.json#knip in ${location}`);
+    }
+    const dir = node_path_1.default.relative(cwd, workingDir);
+    const resolvedConfig = (0, config_1.resolveConfig)(manifest.knip ?? localConfiguration, { workingDir: dir, isDev });
+    if (!resolvedConfig) {
+        throw new Error('Unable to find `entryFiles` and/or `projectFiles` in configuration.');
+    }
+    const report = (0, config_1.resolveIncludedIssueGroups)(include, exclude, resolvedConfig);
+    let tsConfigPaths = [];
+    const tsConfigPath = await (0, fs_1.findFile)(workingDir, tsConfigFilePath ?? 'tsconfig.json');
+    if (tsConfigFilePath && !tsConfigPath) {
+        throw new Error(`Unable to find ${tsConfigFilePath}`);
+    }
+    if (tsConfigPath) {
+        const tsConfig = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
+        tsConfigPaths = tsConfig.config.compilerOptions?.paths
+            ? Object.keys(tsConfig.config.compilerOptions.paths).map(p => p.replace(/\*/g, '**'))
+            : [];
+        if (tsConfig.error) {
+            throw new Error(`An error occured when reading ${node_path_1.default.relative(cwd, tsConfigPath)}`);
+        }
+    }
+    const projectOptions = tsConfigFilePath ? { tsConfigFilePath } : { compilerOptions: { allowJs: true } };
+    const entryPaths = await (0, path_1.resolvePaths)({
+        cwd,
+        workingDir,
+        patterns: resolvedConfig.entryFiles,
+        ignore,
+        gitignore,
+    });
+    const production = (0, project_1.createProject)({ projectOptions, paths: entryPaths });
     const entryFiles = production.getSourceFiles();
     production.resolveSourceFileDependencies();
     const productionFiles = production.getSourceFiles();
-    const project = await (0, project_1.createProject)(configuration, configuration.projectFiles);
+    const projectPaths = await (0, path_1.resolvePaths)({
+        cwd,
+        workingDir,
+        patterns: resolvedConfig.projectFiles,
+        ignore,
+        gitignore,
+    });
+    const project = (0, project_1.createProject)({ projectOptions, paths: projectPaths });
     const projectFiles = project.getSourceFiles();
-    const [usedProductionFiles, unreferencedProductionFiles] = (0, project_1.partitionSourceFiles)(projectFiles, productionFiles);
-    const [usedEntryFiles, usedNonEntryFiles] = (0, project_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
-    const issues = {
-        files: new Set(unreferencedProductionFiles.map(file => file.getFilePath())),
-        dependencies: new Set(),
-        devDependencies: new Set(),
-        unresolved: {},
-        exports: {},
-        types: {},
-        nsExports: {},
-        nsTypes: {},
-        duplicates: {},
-    };
-    const counters = {
-        files: issues.files.size,
-        dependencies: issues.dependencies.size,
-        devDependencies: issues.dependencies.size,
-        unresolved: 0,
-        exports: 0,
-        types: 0,
-        nsExports: 0,
-        nsTypes: 0,
-        duplicates: 0,
-        processed: issues.files.size,
-    };
-    const updateProcessingOutput = (item) => {
-        if (!isShowProgress)
-            return;
-        const counter = unreferencedProductionFiles.length + counters.processed;
-        const total = unreferencedProductionFiles.length + usedNonEntryFiles.length;
-        const percentage = Math.floor((counter / total) * 100);
-        const messages = [(0, log_1.getLine)(`${percentage}%`, `of files processed (${counter} of ${total})`)];
-        report.files && messages.push((0, log_1.getLine)(unreferencedProductionFiles.length, 'unused files'));
-        report.unlisted && messages.push((0, log_1.getLine)(counters.unresolved, 'unlisted dependencies'));
-        report.exports && messages.push((0, log_1.getLine)(counters.exports, 'unused exports'));
-        report.nsExports && messages.push((0, log_1.getLine)(counters.nsExports, 'unused exports in namespace'));
-        report.types && messages.push((0, log_1.getLine)(counters.types, 'unused types'));
-        report.nsTypes && messages.push((0, log_1.getLine)(counters.nsTypes, 'unused types in namespace'));
-        report.duplicates && messages.push((0, log_1.getLine)(counters.duplicates, 'duplicate exports'));
-        if (counter < total) {
-            messages.push('');
-            messages.push(`Processing: ${node_path_1.default.relative(workingDir, item.filePath)}`);
-        }
-        lineRewriter.update(messages);
+    const config = {
+        workingDir,
+        report,
+        entryFiles,
+        productionFiles,
+        projectFiles,
+        dependencies: Object.keys(manifest.dependencies ?? {}),
+        devDependencies: Object.keys(manifest.devDependencies ?? {}),
+        isDev: typeof resolvedConfig.dev === 'boolean' ? resolvedConfig.dev : isDev,
+        tsConfigPaths,
+        isShowProgress,
+        jsDocOptions: {
+            isReadPublicTag: jsDoc.includes('public'),
+        },
     };
-    const addSymbolIssue = (issueType, issue) => {
-        const { filePath, symbol } = issue;
-        const key = node_path_1.default.relative(workingDir, filePath);
-        issues[issueType][key] = issues[issueType][key] ?? {};
-        issues[issueType][key][symbol] = issue;
-        counters[issueType]++;
-        updateProcessingOutput(issue);
-    };
-    const addProjectIssue = (issueType, issue) => {
-        if (!issues[issueType].has(issue.symbol)) {
-            issues[issueType].add(issue.symbol);
-            counters[issueType]++;
-        }
-        updateProcessingOutput(issue);
-    };
-    if (report.dependencies || report.unlisted) {
-        usedEntryFiles.forEach(sourceFile => {
-            const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
-            unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
-        });
-    }
-    if (report.dependencies ||
-        report.unlisted ||
-        report.exports ||
-        report.types ||
-        report.nsExports ||
-        report.nsTypes ||
-        report.duplicates) {
-        usedNonEntryFiles.forEach(sourceFile => {
-            const filePath = sourceFile.getFilePath();
-            if (report.dependencies || report.unlisted) {
-                const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
-                unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
-            }
-            const exportDeclarations = sourceFile.getExportedDeclarations();
-            if (report.duplicates) {
-                const duplicateExports = (0, ts_morph_helpers_1.findDuplicateExportedNames)(sourceFile);
-                duplicateExports.forEach(symbols => {
-                    const symbol = symbols.join('|');
-                    addSymbolIssue('duplicates', { filePath, symbol, symbols });
-                });
-            }
-            if (report.exports || report.types || report.nsExports || report.nsTypes) {
-                const uniqueExportedSymbols = new Set([...exportDeclarations.values()].flat());
-                if (uniqueExportedSymbols.size === 1)
-                    return;
-                exportDeclarations.forEach(declarations => {
-                    declarations.forEach(declaration => {
-                        const type = (0, type_1.getType)(declaration);
-                        if (!report.nsExports && !report.nsTypes) {
-                            if (!report.types && type)
-                                return;
-                            if (!report.exports && !type)
-                                return;
-                        }
-                        if (jsDocOptions.isReadPublicTag && ts_morph_1.ts.getJSDocPublicTag(declaration.compilerNode))
-                            return;
-                        let identifier;
-                        if (declaration.isKind(ts_morph_1.ts.SyntaxKind.Identifier)) {
-                            identifier = declaration;
-                        }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.ArrowFunction)) {
-                        }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.FunctionDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.ClassDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration)) {
-                            identifier = declaration.getFirstChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
-                        }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.PropertyAccessExpression)) {
-                            identifier = declaration.getLastChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
-                        }
-                        else {
-                            identifier = declaration.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.Identifier);
-                        }
-                        if (identifier) {
-                            const identifierText = identifier.getText();
-                            if (report.exports && issues.exports[filePath]?.[identifierText])
-                                return;
-                            if (report.types && issues.types[filePath]?.[identifierText])
-                                return;
-                            if (report.nsExports && issues.nsExports[filePath]?.[identifierText])
-                                return;
-                            if (report.nsTypes && issues.nsTypes[filePath]?.[identifierText])
-                                return;
-                            const refs = identifier.findReferences();
-                            if (refs.length === 0) {
-                                addSymbolIssue('exports', { filePath, symbol: identifierText });
-                            }
-                            else {
-                                const refFiles = new Set(refs.map(r => r.compilerObject.references.map(r => r.fileName)).flat());
-                                const isReferencedOnlyBySelf = refFiles.size === 1 && [...refFiles][0] === filePath;
-                                if (!isReferencedOnlyBySelf)
-                                    return;
-                                if ((0, ts_morph_helpers_1.findReferencingNamespaceNodes)(sourceFile).length > 0) {
-                                    if (type) {
-                                        addSymbolIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
-                                    }
-                                    else {
-                                        addSymbolIssue('nsExports', { filePath, symbol: identifierText });
-                                    }
-                                }
-                                else if (type) {
-                                    addSymbolIssue('types', { filePath, symbol: identifierText, symbolType: type });
-                                }
-                                else {
-                                    addSymbolIssue('exports', { filePath, symbol: identifierText });
-                                }
-                            }
-                        }
-                    });
-                });
-            }
-            counters.processed++;
-        });
-    }
-    if (report.dependencies) {
-        const unusedDependencies = getUnusedDependencies();
-        unusedDependencies.forEach(symbol => addProjectIssue('dependencies', { filePath: '', symbol }));
-        if (isDev) {
-            const unusedDevDependencies = getUnusedDevDependencies();
-            unusedDevDependencies.forEach(symbol => addProjectIssue('devDependencies', { filePath: '', symbol }));
-        }
-    }
-    if (isShowProgress)
-        lineRewriter.resetLines();
-    return { issues, counters };
-}
-exports.run = run;
+    const { issues, counters } = await (0, runner_1.findIssues)(config);
+    return { report, issues, counters };
+};
+exports.main = main;

package/dist/reporters/compact.d.ts

@@ -1,7 +1,8 @@
-import type { Issues, Configuration } from '../types';
-declare const _default: ({ issues, config, workingDir }: {
+import type { Issues, Report } from '../types';
+declare const _default: ({ report, issues, workingDir, isDev, }: {
+    report: Report;
     issues: Issues;
-    config: Configuration;
     workingDir: string;
+    isDev: boolean;
 }) => void;
 export default _default;

package/dist/reporters/compact.js

@@ -26,8 +26,7 @@ const logIssueGroupResults = (issues, workingDir, title) => {
         console.log('Not found');
     }
 };
-exports.default = ({ issues, config, workingDir }) => {
-    const { report, isDev } = config;
+exports.default = ({ report, issues, workingDir, isDev, }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     if (report.files) {
         const unreferencedFiles = Array.from(issues.files);

package/dist/reporters/index.d.ts

@@ -1,13 +1,15 @@
 declare const _default: {
-    symbols: ({ issues, config, workingDir }: {
+    symbols: ({ report, issues, workingDir, isDev, }: {
+        report: import("../types").Report;
         issues: import("../types").Issues;
-        config: import("../types").Configuration;
         workingDir: string;
+        isDev: boolean;
     }) => void;
-    compact: ({ issues, config, workingDir }: {
+    compact: ({ report, issues, workingDir, isDev, }: {
+        report: import("../types").Report;
         issues: import("../types").Issues;
-        config: import("../types").Configuration;
         workingDir: string;
+        isDev: boolean;
     }) => void;
 };
 export default _default;

package/dist/reporters/symbols.d.ts

@@ -1,7 +1,8 @@
-import type { Issues, Configuration } from '../types';
-declare const _default: ({ issues, config, workingDir }: {
+import type { Issues, Report } from '../types';
+declare const _default: ({ report, issues, workingDir, isDev, }: {
+    report: Report;
     issues: Issues;
-    config: Configuration;
     workingDir: string;
+    isDev: boolean;
 }) => void;
 export default _default;

package/dist/reporters/symbols.js

@@ -28,8 +28,7 @@ const logIssueGroupResults = (issues, workingDir, title) => {
         console.log('Not found');
     }
 };
-exports.default = ({ issues, config, workingDir }) => {
-    const { report, isDev } = config;
+exports.default = ({ report, issues, workingDir, isDev, }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     if (report.files) {
         const unreferencedFiles = Array.from(issues.files);

package/dist/runner.d.ts

@@ -0,0 +1,16 @@
+import type { Configuration, Issues } from './types';
+export declare function findIssues(configuration: Configuration): Promise<{
+    issues: Issues;
+    counters: {
+        files: number;
+        dependencies: number;
+        devDependencies: number;
+        unresolved: number;
+        exports: number;
+        types: number;
+        nsExports: number;
+        nsTypes: number;
+        duplicates: number;
+        processed: number;
+    };
+}>;

package/dist/runner.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIssues = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ts_morph_1 = require("ts-morph");
+const ts_morph_helpers_1 = require("ts-morph-helpers");
+const project_1 = require("./util/project");
+const type_1 = require("./util/type");
+const dependencies_1 = require("./util/dependencies");
+const log_1 = require("./log");
+const lineRewriter = new log_1.LineRewriter();
+async function findIssues(configuration) {
+    const { workingDir, isShowProgress, report, isDev, jsDocOptions } = configuration;
+    const { entryFiles, productionFiles, projectFiles } = configuration;
+    const { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies } = (0, dependencies_1.getDependencyAnalyzer)(configuration);
+    const [usedProductionFiles, unreferencedProductionFiles] = (0, project_1.partitionSourceFiles)(projectFiles, productionFiles);
+    const [usedEntryFiles, usedNonEntryFiles] = (0, project_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
+    const issues = {
+        files: new Set(unreferencedProductionFiles.map(file => file.getFilePath())),
+        dependencies: new Set(),
+        devDependencies: new Set(),
+        unresolved: {},
+        exports: {},
+        types: {},
+        nsExports: {},
+        nsTypes: {},
+        duplicates: {},
+    };
+    const counters = {
+        files: issues.files.size,
+        dependencies: issues.dependencies.size,
+        devDependencies: issues.dependencies.size,
+        unresolved: 0,
+        exports: 0,
+        types: 0,
+        nsExports: 0,
+        nsTypes: 0,
+        duplicates: 0,
+        processed: issues.files.size,
+    };
+    const updateProcessingOutput = (item) => {
+        if (!isShowProgress)
+            return;
+        const counter = unreferencedProductionFiles.length + counters.processed;
+        const total = unreferencedProductionFiles.length + usedNonEntryFiles.length;
+        const percentage = Math.floor((counter / total) * 100);
+        const messages = [(0, log_1.getLine)(`${percentage}%`, `of files processed (${counter} of ${total})`)];
+        report.files && messages.push((0, log_1.getLine)(unreferencedProductionFiles.length, 'unused files'));
+        report.unlisted && messages.push((0, log_1.getLine)(counters.unresolved, 'unlisted dependencies'));
+        report.exports && messages.push((0, log_1.getLine)(counters.exports, 'unused exports'));
+        report.nsExports && messages.push((0, log_1.getLine)(counters.nsExports, 'unused exports in namespace'));
+        report.types && messages.push((0, log_1.getLine)(counters.types, 'unused types'));
+        report.nsTypes && messages.push((0, log_1.getLine)(counters.nsTypes, 'unused types in namespace'));
+        report.duplicates && messages.push((0, log_1.getLine)(counters.duplicates, 'duplicate exports'));
+        if (counter < total) {
+            messages.push('');
+            messages.push(`Processing: ${node_path_1.default.relative(workingDir, item.filePath)}`);
+        }
+        lineRewriter.update(messages);
+    };
+    const addSymbolIssue = (issueType, issue) => {
+        const { filePath, symbol } = issue;
+        const key = node_path_1.default.relative(workingDir, filePath);
+        issues[issueType][key] = issues[issueType][key] ?? {};
+        issues[issueType][key][symbol] = issue;
+        counters[issueType]++;
+        updateProcessingOutput(issue);
+    };
+    const addProjectIssue = (issueType, issue) => {
+        if (!issues[issueType].has(issue.symbol)) {
+            issues[issueType].add(issue.symbol);
+            counters[issueType]++;
+        }
+        updateProcessingOutput(issue);
+    };
+    if (report.dependencies || report.unlisted) {
+        usedEntryFiles.forEach(sourceFile => {
+            const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
+            unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
+        });
+    }
+    if (report.dependencies ||
+        report.unlisted ||
+        report.exports ||
+        report.types ||
+        report.nsExports ||
+        report.nsTypes ||
+        report.duplicates) {
+        usedNonEntryFiles.forEach(sourceFile => {
+            const filePath = sourceFile.getFilePath();
+            if (report.dependencies || report.unlisted) {
+                const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
+                unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
+            }
+            const exportDeclarations = sourceFile.getExportedDeclarations();
+            if (report.duplicates) {
+                const duplicateExports = (0, ts_morph_helpers_1.findDuplicateExportedNames)(sourceFile);
+                duplicateExports.forEach(symbols => {
+                    const symbol = symbols.join('|');
+                    addSymbolIssue('duplicates', { filePath, symbol, symbols });
+                });
+            }
+            if (report.exports || report.types || report.nsExports || report.nsTypes) {
+                const uniqueExportedSymbols = new Set([...exportDeclarations.values()].flat());
+                if (uniqueExportedSymbols.size === 1)
+                    return;
+                exportDeclarations.forEach(declarations => {
+                    declarations.forEach(declaration => {
+                        const type = (0, type_1.getType)(declaration);
+                        if (!report.nsExports && !report.nsTypes) {
+                            if (!report.types && type)
+                                return;
+                            if (!report.exports && !type)
+                                return;
+                        }
+                        if (jsDocOptions.isReadPublicTag && ts_morph_1.ts.getJSDocPublicTag(declaration.compilerNode))
+                            return;
+                        let identifier;
+                        if (declaration.isKind(ts_morph_1.ts.SyntaxKind.Identifier)) {
+                            identifier = declaration;
+                        }
+                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.ArrowFunction)) {
+                        }
+                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.FunctionDeclaration) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.ClassDeclaration) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration)) {
+                            identifier = declaration.getFirstChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.PropertyAccessExpression)) {
+                            identifier = declaration.getLastChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        else {
+                            identifier = declaration.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        if (identifier) {
+                            const identifierText = identifier.getText();
+                            if (report.exports && issues.exports[filePath]?.[identifierText])
+                                return;
+                            if (report.types && issues.types[filePath]?.[identifierText])
+                                return;
+                            if (report.nsExports && issues.nsExports[filePath]?.[identifierText])
+                                return;
+                            if (report.nsTypes && issues.nsTypes[filePath]?.[identifierText])
+                                return;
+                            const refs = identifier.findReferences();
+                            if (refs.length === 0) {
+                                addSymbolIssue('exports', { filePath, symbol: identifierText });
+                            }
+                            else {
+                                const refFiles = new Set(refs.map(r => r.compilerObject.references.map(r => r.fileName)).flat());
+                                const isReferencedOnlyBySelf = refFiles.size === 1 && [...refFiles][0] === filePath;
+                                if (!isReferencedOnlyBySelf)
+                                    return;
+                                if ((0, ts_morph_helpers_1.findReferencingNamespaceNodes)(sourceFile).length > 0) {
+                                    if (type) {
+                                        addSymbolIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
+                                    }
+                                    else {
+                                        addSymbolIssue('nsExports', { filePath, symbol: identifierText });
+                                    }
+                                }
+                                else if (type) {
+                                    addSymbolIssue('types', { filePath, symbol: identifierText, symbolType: type });
+                                }
+                                else {
+                                    addSymbolIssue('exports', { filePath, symbol: identifierText });
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+            counters.processed++;
+        });
+    }
+    if (report.dependencies) {
+        const unusedDependencies = getUnusedDependencies();
+        unusedDependencies.forEach(symbol => addProjectIssue('dependencies', { filePath: '', symbol }));
+        if (isDev) {
+            const unusedDevDependencies = getUnusedDevDependencies();
+            unusedDevDependencies.forEach(symbol => addProjectIssue('devDependencies', { filePath: '', symbol }));
+        }
+    }
+    if (isShowProgress)
+        lineRewriter.resetLines();
+    return { issues, counters };
+}
+exports.findIssues = findIssues;

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { SourceFile } from 'ts-morph';
 declare type SymbolType = 'type' | 'interface' | 'enum';
 declare type UnusedFileIssues = Set<string>;
 declare type UnusedExportIssues = Record<string, Record<string, Issue>>;
@@ -30,23 +31,36 @@ declare type BaseLocalConfiguration = {
 };
 export declare type LocalConfiguration = BaseLocalConfiguration & {
     dev?: boolean | BaseLocalConfiguration;
-    entryFiles: string[];
-    projectFiles: string[];
     include?: string[];
     exclude?: string[];
 };
 export declare type ImportedConfiguration = LocalConfiguration | Record<string, LocalConfiguration>;
-export declare type Configuration = LocalConfiguration & {
+export declare type UnresolvedConfiguration = {
+    cwd: string;
     workingDir: string;
-    report: {
-        [key in IssueGroup]: boolean;
-    };
+    configFilePath?: string;
+    tsConfigFilePath?: string;
+    include: string[];
+    exclude: string[];
+    ignore: string[];
+    gitignore: boolean;
+    isDev: boolean;
+    isShowProgress: boolean;
+    jsDoc: string[];
+};
+export declare type Report = {
+    [key in IssueGroup]: boolean;
+};
+export declare type Configuration = {
+    workingDir: string;
+    report: Report;
+    projectFiles: SourceFile[];
+    productionFiles: SourceFile[];
+    entryFiles: SourceFile[];
     dependencies: string[];
     devDependencies: string[];
     isDev: boolean;
-    tsConfigFilePath: undefined | string;
     tsConfigPaths: string[];
-    ignorePatterns: string[];
     isShowProgress: boolean;
     jsDocOptions: {
         isReadPublicTag: boolean;

package/dist/util/config.d.ts

@@ -3,13 +3,4 @@ export declare const resolveConfig: (importedConfiguration: ImportedConfiguratio
     workingDir?: string;
     isDev?: boolean;
 }) => LocalConfiguration | undefined;
-export declare const resolveIncludedIssueGroups: (includeArg: string[], excludeArg: string[], resolvedConfig?: LocalConfiguration) => {
-    files: boolean;
-    dependencies: boolean;
-    exports: boolean;
-    types: boolean;
-    nsExports: boolean;
-    nsTypes: boolean;
-    duplicates: boolean;
-    unlisted: boolean;
-};
+export declare const resolveIncludedIssueGroups: (includeArg: string[], excludeArg: string[], resolvedConfig?: LocalConfiguration) => import("../types").Report;

package/dist/util/config.js

@@ -19,8 +19,7 @@ const resolveConfig = (importedConfiguration, options) => {
         resolvedConfig = resolvedConfig.dev;
     }
     if (!resolvedConfig.entryFiles || !resolvedConfig.projectFiles) {
-        console.error('Unable to find `entryFiles` and/or `projectFiles` in configuration.');
-        console.info(`Add these properties at root level, or use --cwd and match one of: ${configKeys.join(', ')}\n`);
+        console.info(`Add these properties at root level, or use --dir and match one of: ${configKeys.join(', ')}\n`);
         return;
     }
     return resolvedConfig;

package/dist/util/path.d.ts

@@ -1,3 +1,8 @@
-import type { Configuration } from '../types';
-export declare const addWorkingDirToPattern: (workingDir: string, pattern: string) => string;
-export declare const resolvePaths: (configuration: Configuration, patterns: string[]) => string[];
+export declare const prependDirToPattern: (workingDir: string, pattern: string) => string;
+export declare const resolvePaths: ({ cwd, workingDir, patterns, ignore, gitignore, }: {
+    cwd: string;
+    workingDir: string;
+    patterns: string[];
+    ignore: string[];
+    gitignore: boolean;
+}) => Promise<string[]>;

package/dist/util/path.js

@@ -3,16 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePaths = exports.addWorkingDirToPattern = void 0;
+exports.resolvePaths = exports.prependDirToPattern = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const addWorkingDirToPattern = (workingDir, pattern) => {
+let _globby;
+const glob = async function (patterns, options) {
+    if (!_globby) {
+        const { globby } = await eval('import("globby")');
+        _globby = globby;
+    }
+    return _globby(patterns, options);
+};
+const prependDirToPattern = (workingDir, pattern) => {
     if (pattern.startsWith('!'))
         return '!' + node_path_1.default.join(workingDir, pattern.slice(1));
     return node_path_1.default.join(workingDir, pattern);
 };
-exports.addWorkingDirToPattern = addWorkingDirToPattern;
-const resolvePaths = (configuration, patterns) => {
-    const { workingDir } = configuration;
-    return patterns.map(pattern => (0, exports.addWorkingDirToPattern)(workingDir, pattern));
-};
+exports.prependDirToPattern = prependDirToPattern;
+const resolvePaths = async ({ cwd, workingDir, patterns, ignore, gitignore, }) => glob(patterns.map(pattern => (0, exports.prependDirToPattern)(node_path_1.default.relative(cwd, workingDir), pattern)), {
+    cwd,
+    ignore,
+    gitignore,
+    absolute: true,
+});
 exports.resolvePaths = resolvePaths;

package/dist/util/project.d.ts

@@ -1,5 +1,7 @@
 import { Project } from 'ts-morph';
-import type { SourceFile } from 'ts-morph';
-import type { Configuration } from '../types';
-export declare const createProject: (configuration: Configuration, paths?: string[]) => Promise<Project>;
+import type { ProjectOptions, SourceFile } from 'ts-morph';
+export declare const createProject: ({ projectOptions, paths }: {
+    projectOptions: ProjectOptions;
+    paths?: string[] | undefined;
+}) => Project;
 export declare const partitionSourceFiles: (projectFiles: SourceFile[], productionFiles: SourceFile[]) => SourceFile[][];

package/dist/util/project.js

@@ -2,19 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.partitionSourceFiles = exports.createProject = void 0;
 const ts_morph_1 = require("ts-morph");
-const path_1 = require("./path");
-const createProject = async (configuration, paths) => {
-    const { tsConfigFilePath, ignorePatterns } = configuration;
-    const tsConfig = tsConfigFilePath ? { tsConfigFilePath } : { compilerOptions: { allowJs: true } };
+const createProject = ({ projectOptions, paths }) => {
     const workspace = new ts_morph_1.Project({
-        ...tsConfig,
+        ...projectOptions,
         skipAddingFilesFromTsConfig: true,
         skipFileDependencyResolution: true,
     });
-    if (paths) {
-        const resolvedPaths = (0, path_1.resolvePaths)(configuration, paths);
-        workspace.addSourceFilesAtPaths([...resolvedPaths, ...ignorePatterns]);
-    }
+    if (paths)
+        workspace.addSourceFilesAtPaths(paths);
     return workspace;
 };
 exports.createProject = createProject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Find unused files and exports in your TypeScript project",
   "keywords": [
     "find",
@@ -38,6 +38,7 @@
   },
   "license": "ISC",
   "dependencies": {
+    "globby": "13.1.2",
     "is-builtin-module": "3.2.0",
     "micromatch": "4.0.5",
     "ts-morph": "16.0.0",

package/dist/util/ignore.d.ts

@@ -1,2 +0,0 @@
-export declare const convertPattern: (pattern: string) => string;
-export declare const readIgnorePatterns: (cwd: string, workingDir: string) => Promise<string[]>;

package/dist/util/ignore.js

@@ -1,38 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readIgnorePatterns = exports.convertPattern = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const fs_1 = require("./fs");
-const path_1 = require("./path");
-const convertPattern = (pattern) => (pattern.startsWith('!') ? pattern.substring(1) : `!${pattern}`);
-exports.convertPattern = convertPattern;
-const readIgnoreFile = async (filePath) => {
-    let contents = '';
-    try {
-        contents = (await promises_1.default.readFile(filePath)).toString();
-    }
-    catch (error) {
-    }
-    return contents.split(/\r?\n/).filter(line => line && !line.startsWith('#'));
-};
-const traverseDirs = async (rootDir, currentDir, patterns = []) => {
-    const gitIgnorePath = node_path_1.default.join(currentDir, '.gitignore');
-    const parentDir = node_path_1.default.resolve(currentDir, '..');
-    if (await (0, fs_1.isFile)(gitIgnorePath)) {
-        (await readIgnoreFile(gitIgnorePath))
-            .map(pattern => (0, path_1.addWorkingDirToPattern)(currentDir, pattern))
-            .forEach(pattern => patterns.push(pattern));
-    }
-    if (rootDir === currentDir || parentDir === '/')
-        return patterns;
-    return traverseDirs(rootDir, parentDir, patterns);
-};
-const readIgnorePatterns = async (cwd, workingDir) => {
-    const patterns = await traverseDirs(cwd, workingDir);
-    return patterns.map(exports.convertPattern);
-};
-exports.readIgnorePatterns = readIgnorePatterns;