knip 0.3.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:
 
@@ -79,16 +79,18 @@ Please read on if you think you have too many results: [too many false positives
 knip [options]
 
 Options:
-  -c/--config [file]   Configuration file path (default: ./knip.json or package.json#knip)
-  -t/--tsConfig [file] TypeScript configuration path (default: ./tsconfig.json)
-  --dir                Working directory (default: current working directory)
-  --include            Report only listed issue group(s) (see below)
-  --exclude            Exclude issue group(s) from report (see below)
-  --dev                Include `devDependencies` in report(s) (default: false)
-  --no-progress        Don't show dynamic progress updates
-  --max-issues         Maximum number of issues before non-zero exit code (default: 0)
-  --reporter           Select reporter: symbols, compact (default: symbols)
-  --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
+  -c/--config [file]     Configuration file path (default: ./knip.json or package.json#knip)
+  -t/--tsConfig [file]   TypeScript configuration path (default: ./tsconfig.json)
+  --dir                  Working directory (default: current working directory)
+  --include              Report only listed issue group(s) (see below)
+  --exclude              Exclude issue group(s) from report (see below)
+  --ignore               Ignore files matching this glob pattern (can be set multiple times)
+  --no-gitignore         Don't use .gitignore
+  --dev                  Include `devDependencies` in report(s)
+  --no-progress          Don't show dynamic progress updates
+  --max-issues           Maximum number of issues before non-zero exit code (default: 0)
+  --reporter             Select reporter: symbols, compact (default: symbols)
+  --jsdoc                Enable JSDoc parsing, with options: public
 
 Issue groups: files, dependencies, unlisted, exports, nsExports, types, nsTypes, duplicates
 
@@ -97,6 +99,7 @@ Examples:
 $ knip
 $ knip --dir packages/client --include files
 $ knip -c ./knip.js --reporter compact --jsdoc public
+$ knip --ignore 'lib/**/*.ts' --ignore build
 
 More info: https://github.com/webpro/knip
 ```
@@ -139,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!).
@@ -159,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`:
 
@@ -189,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
@@ -206,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
@@ -293,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,13 +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 path_1 = require("./util/path");
 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, 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' },
@@ -20,9 +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 },
+        ignore: { type: 'string', multiple: true },
+        'no-gitignore': { type: 'boolean' },
         dev: { type: 'boolean' },
-        'max-issues': { type: 'string' },
         'no-progress': { type: 'boolean' },
+        'max-issues': { type: 'string' },
         reporter: { type: 'string' },
         jsdoc: { type: 'string', multiple: true },
     },
@@ -35,63 +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, path_1.findFile)(workingDir, configFilePath);
-    const manifestPath = await (0, path_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, path_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 config = {
-        workingDir,
-        report,
-        dependencies: Object.keys(manifest.dependencies ?? {}),
-        devDependencies: Object.keys(manifest.devDependencies ?? {}),
-        isDev: typeof resolvedConfig.dev === 'boolean' ? resolvedConfig.dev : isDev,
-        tsConfigFilePath,
-        tsConfigPaths,
-        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/help.js

@@ -5,16 +5,18 @@ const printHelp = () => {
     console.log(`knip [options]
 
 Options:
-  -c/--config [file]   Configuration file path (default: ./knip.json or package.json#knip)
-  -t/--tsConfig [file] TypeScript configuration path (default: ./tsconfig.json)
-  --dir                Working directory (default: current working directory)
-  --include            Report only listed issue group(s) (see below)
-  --exclude            Exclude issue group(s) from report (see below)
-  --dev                Include \`devDependencies\` in report(s) (default: false)
-  --no-progress        Don't show dynamic progress updates
-  --max-issues         Maximum number of issues before non-zero exit code (default: 0)
-  --reporter           Select reporter: symbols, compact (default: symbols)
-  --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
+  -c/--config [file]     Configuration file path (default: ./knip.json or package.json#knip)
+  -t/--tsConfig [file]   TypeScript configuration path (default: ./tsconfig.json)
+  --dir                  Working directory (default: current working directory)
+  --include              Report only listed issue group(s) (see below)
+  --exclude              Exclude issue group(s) from report (see below)
+  --ignore               Ignore files matching this glob pattern (can be set multiple times)
+  --no-gitignore         Don't use .gitignore
+  --dev                  Include \`devDependencies\` in report(s)
+  --no-progress          Don't show dynamic progress updates
+  --max-issues           Maximum number of issues before non-zero exit code (default: 0)
+  --reporter             Select reporter: symbols, compact (default: symbols)
+  --jsdoc                Enable JSDoc parsing, with options: public
 
 Issue groups: files, dependencies, unlisted, exports, nsExports, types, nsTypes, duplicates
 
@@ -23,6 +25,7 @@ Examples:
 $ knip
 $ knip --dir packages/client --include files
 $ knip -c ./knip.js --reporter compact --jsdoc public
+$ knip --ignore 'lib/**/*.ts' --ignore build
 
 More info: https://github.com/webpro/knip`);
 };

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>>;
@@ -20,31 +21,45 @@ export declare type Issues = {
     nsTypes: UnusedExportIssues;
     duplicates: UnusedExportIssues;
 };
-export declare type IssueType = keyof Issues;
+declare type IssueType = keyof Issues;
 export declare type ProjectIssueType = Extract<IssueType, 'files' | 'dependencies' | 'devDependencies'>;
 export declare type SymbolIssueType = Exclude<IssueType, ProjectIssueType>;
 export declare type IssueGroup = 'files' | 'dependencies' | 'unlisted' | 'exports' | 'nsExports' | 'types' | 'nsTypes' | 'duplicates';
-export declare type BaseLocalConfiguration = {
+declare type BaseLocalConfiguration = {
     entryFiles: string[];
     projectFiles: string[];
 };
 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[];
     isShowProgress: boolean;
     jsDocOptions: {

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/fs.d.ts

@@ -0,0 +1,2 @@
+export declare const isFile: (filePath: string) => Promise<boolean>;
+export declare const findFile: (cwd: string, fileName: string) => Promise<string | undefined>;

package/dist/util/fs.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFile = exports.isFile = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const isFile = async (filePath) => {
+    try {
+        const stats = await promises_1.default.stat(filePath);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+};
+exports.isFile = isFile;
+const findFile = async (cwd, fileName) => {
+    const filePath = node_path_1.default.join(cwd, fileName);
+    if (await (0, exports.isFile)(filePath)) {
+        return filePath;
+    }
+    else {
+        const parentDir = node_path_1.default.resolve(cwd, '..');
+        return parentDir === '/' ? undefined : (0, exports.findFile)(parentDir, fileName);
+    }
+};
+exports.findFile = findFile;

package/dist/util/path.d.ts

@@ -1 +1,8 @@
-export declare const findFile: (cwd: string, fileName: string) => Promise<string | undefined>;
+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,26 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findFile = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
+exports.resolvePaths = exports.prependDirToPattern = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const isFile = async (filePath) => {
-    try {
-        const stats = await promises_1.default.stat(filePath);
-        return stats.isFile();
-    }
-    catch {
-        return false;
+let _globby;
+const glob = async function (patterns, options) {
+    if (!_globby) {
+        const { globby } = await eval('import("globby")');
+        _globby = globby;
     }
+    return _globby(patterns, options);
 };
-const findFile = async (cwd, fileName) => {
-    const filePath = node_path_1.default.join(cwd, fileName);
-    if (await isFile(filePath)) {
-        return filePath;
-    }
-    else {
-        const parentDir = node_path_1.default.resolve(cwd, '..');
-        return parentDir === '/' ? undefined : (0, exports.findFile)(parentDir, fileName);
-    }
+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.findFile = findFile;
+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 | 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

@@ -1,28 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.partitionSourceFiles = exports.createProject = void 0;
-const node_path_1 = __importDefault(require("node:path"));
 const ts_morph_1 = require("ts-morph");
-const resolvePaths = (cwd, patterns) => {
-    return [patterns].flat().map(pattern => {
-        if (pattern.startsWith('!'))
-            return '!' + node_path_1.default.join(cwd, pattern.slice(1));
-        return node_path_1.default.join(cwd, pattern);
-    });
-};
-const createProject = async (configuration, paths) => {
-    const { tsConfigFilePath, workingDir } = 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)
-        workspace.addSourceFilesAtPaths(resolvePaths(workingDir, paths));
+        workspace.addSourceFilesAtPaths(paths);
     return workspace;
 };
 exports.createProject = createProject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "0.3.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",