knip 2.7.0 → 2.8.0

package/README.md

@@ -646,7 +646,27 @@ Many thanks to some of the early adopters of Knip:
 - [release-it][27]
 - [Template TypeScript Node Package][28]
 
-## Knip?!
+## 🐣 Super Secret Easter Egg Boost 🚀
+
+Running Knip on large workspaces with many packages may feel a bit sluggish. Knip looks up `.gitignore` files and uses
+them to filter out matching entry and project files. This increases correctness. However, you might want to disable that
+with `--no-gitignore` and enjoy a significant performance boost. Depending on the contents of the `.gitignore` files,
+the reported issues may be the same. To help determine whether this trade-off might be worth it for you, first check the
+difference in unused files:
+
+```shell
+diff <(knip --no-gitignore --include files) <(knip --include files)
+```
+
+And to measure the difference of this flag in seconds:
+
+```shell
+SECONDS=0; knip > /dev/null; t1=$SECONDS; SECONDS=0; knip --no-gitignore > /dev/null; t2=$SECONDS; echo "Difference: $((t1 - t2)) seconds"
+```
+
+⏲️ Analysis on a large project went from 33 down to 9 seconds (that's >70% faster). Happy Easter! 🐣
+
+## 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! ✂️

package/dist/ConfigurationChief.d.ts

@@ -44,6 +44,7 @@ export declare class ConfigurationChief {
             duplicates: import("./types/issues.js").IssueSeverity;
             enumMembers: import("./types/issues.js").IssueSeverity;
             classMembers: import("./types/issues.js").IssueSeverity;
+            binaries: import("./types/issues.js").IssueSeverity;
         };
         include: string[];
         exclude: string[];
@@ -67,5 +68,6 @@ export declare class ConfigurationChief {
     getIssueTypesToReport(): import("./types/issues.js").Report;
     findWorkspaceByFilePath(filePath: string): Workspace | undefined;
     findWorkspaceByPackageName(packageName: string): Workspace | undefined;
+    getUnusedIgnoredWorkspaces(): string[];
 }
 export {};

package/dist/ConfigurationChief.js

@@ -264,4 +264,9 @@ export class ConfigurationChief {
     findWorkspaceByPackageName(packageName) {
         return this.workspaces.find(workspace => workspace.pkgName === packageName);
     }
+    getUnusedIgnoredWorkspaces() {
+        const ignoredWorkspaceNames = this.config.ignoreWorkspaces;
+        const workspaceNames = this.getAllWorkspaces();
+        return ignoredWorkspaceNames.filter(workspaceName => !workspaceNames.includes(workspaceName));
+    }
 }

package/dist/DependencyDeputy.d.ts

@@ -1,5 +1,5 @@
 import { Workspace } from './ConfigurationChief.js';
-import type { Issue } from './types/issues.js';
+import type { ConfigurationHints, Issue } from './types/issues.js';
 import type { WorkspaceManifests } from './types/workspace.js';
 import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
 import type { PackageJson } from 'type-fest';
@@ -10,6 +10,7 @@ export declare class DependencyDeputy {
     isStrict: boolean;
     _manifests: WorkspaceManifests;
     referencedDependencies: Map<string, Set<string>>;
+    referencedBinaries: Map<string, Set<string>>;
     peerDependencies: Map<string, PeerDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     constructor({ isStrict }: Options);
@@ -38,13 +39,16 @@ export declare class DependencyDeputy {
     setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
     getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;
     addReferencedDependency(workspaceName: string, packageName: string): void;
+    addReferencedBinary(workspaceName: string, binaryName: string): void;
     addPeerDependencies(workspaceName: string, peerDependencies: Map<string, Set<string>>): void;
     getPeerDependencies(workspaceName: string, dependency: string): string[];
     maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
+    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
     private isInDependencies;
     settleDependencyIssues(): {
         dependencyIssues: Issue[];
         devDependencyIssues: Issue[];
+        configurationHints: ConfigurationHints;
     };
 }
 export {};

package/dist/DependencyDeputy.js

@@ -1,16 +1,17 @@
 import { isBuiltin } from 'node:module';
-import { fromBinary, isBinary } from './binaries/util.js';
 import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 export class DependencyDeputy {
     isStrict;
     _manifests = new Map();
     referencedDependencies;
+    referencedBinaries;
     peerDependencies;
     installedBinaries;
     constructor({ isStrict }) {
         this.isStrict = isStrict;
         this.referencedDependencies = new Map();
+        this.referencedBinaries = new Map();
         this.peerDependencies = new Map();
         this.installedBinaries = new Map();
     }
@@ -60,6 +61,12 @@ export class DependencyDeputy {
         }
         this.referencedDependencies.get(workspaceName)?.add(packageName);
     }
+    addReferencedBinary(workspaceName, binaryName) {
+        if (!this.referencedBinaries.has(workspaceName)) {
+            this.referencedBinaries.set(workspaceName, new Set());
+        }
+        this.referencedBinaries.get(workspaceName)?.add(binaryName);
+    }
     addPeerDependencies(workspaceName, peerDependencies) {
         this.peerDependencies.set(workspaceName, peerDependencies);
     }
@@ -73,24 +80,6 @@ export class DependencyDeputy {
             return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
-        if (isBinary(packageName)) {
-            const binaryName = fromBinary(packageName);
-            if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
-                return true;
-            if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
-                return true;
-            for (const name of workspaceNames) {
-                const binaries = this.getInstalledBinaries(name);
-                if (binaries?.has(binaryName)) {
-                    const dependencies = binaries.get(binaryName);
-                    if (dependencies?.size) {
-                        dependencies.forEach(dependency => this.addReferencedDependency(name, dependency));
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
         if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))
             return true;
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
@@ -102,6 +91,25 @@ export class DependencyDeputy {
         }
         return false;
     }
+    maybeAddReferencedBinary(workspace, binaryName) {
+        if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
+            return true;
+        this.addReferencedBinary(workspace.name, binaryName);
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
+            return true;
+        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
+        for (const name of workspaceNames) {
+            const binaries = this.getInstalledBinaries(name);
+            if (binaries?.has(binaryName)) {
+                const dependencies = binaries.get(binaryName);
+                if (dependencies?.size) {
+                    dependencies.forEach(dependency => this.addReferencedDependency(name, dependency));
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     isInDependencies(workspaceName, packageName) {
         const manifest = this._manifests.get(workspaceName);
         if (!manifest)
@@ -112,8 +120,10 @@ export class DependencyDeputy {
     settleDependencyIssues() {
         const dependencyIssues = [];
         const devDependencyIssues = [];
+        const configurationHints = new Set();
         for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
+            const referencedBinaries = this.referencedBinaries.get(workspaceName);
             const installedBinaries = this.getInstalledBinaries(workspaceName);
             const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...ignoreBinaries];
             const ignoreDeps = [...IGNORED_DEPENDENCIES, ...ignoreDependencies];
@@ -146,17 +156,25 @@ export class DependencyDeputy {
                 }
                 return false;
             };
-            this.getProductionDependencies(workspaceName)
-                .filter(isNotIgnoredDependency)
+            const pd = this.getProductionDependencies(workspaceName);
+            const dd = this.getDevDependencies(workspaceName);
+            pd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
                 .filter(isNotReferencedDependency)
                 .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
-            this.getDevDependencies(workspaceName)
-                .filter(isNotIgnoredDependency)
+            dd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
                 .filter(isNotReferencedDependency)
                 .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
+            const isReferencedDep = (name) => ![...pd, ...dd].includes(name) && referencedDependencies?.has(name);
+            const isReferencedBin = (name) => !installedBinaries?.has(name) && referencedBinaries?.has(name);
+            ignoreDependencies
+                .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) || !isReferencedDep(packageName))
+                .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' }));
+            ignoreBinaries
+                .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) || !isReferencedBin(binaryName))
+                .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
-        return { dependencyIssues, devDependencyIssues };
+        return { dependencyIssues, devDependencyIssues, configurationHints };
     }
 }

package/dist/IssueCollector.d.ts

@@ -1,4 +1,4 @@
-import type { Issue, Rules } from './types/issues.js';
+import type { ConfigurationHint, Issue, Rules } from './types/issues.js';
 type IssueCollectorOptions = {
     cwd: string;
     rules: Rules;
@@ -9,6 +9,7 @@ export declare class IssueCollector {
     private issues;
     private counters;
     private referencedFiles;
+    private configurationHints;
     constructor({ cwd, rules }: IssueCollectorOptions);
     addFileCounts({ processed, unused }: {
         processed: number;
@@ -16,9 +17,11 @@ export declare class IssueCollector {
     }): void;
     addFilesIssues(filePaths: string[]): void;
     addIssue(issue: Issue): void;
+    addConfigurationHint(issue: ConfigurationHint): void;
     getIssues(): {
         issues: import("./types/issues.js").Issues;
         counters: import("./types/issues.js").Counters;
+        configurationHints: Set<unknown>;
     };
 }
 export {};

package/dist/IssueCollector.js

@@ -6,6 +6,7 @@ export class IssueCollector {
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
+    configurationHints = new Set();
     constructor({ cwd, rules }) {
         this.cwd = cwd;
         this.rules = rules;
@@ -32,10 +33,14 @@ export class IssueCollector {
             this.counters[issue.type]++;
         }
     }
+    addConfigurationHint(issue) {
+        this.configurationHints.add(issue);
+    }
     getIssues() {
         return {
             issues: this.issues,
             counters: this.counters,
+            configurationHints: this.configurationHints,
         };
     }
 }

package/dist/cli.js

@@ -23,7 +23,7 @@ const printReport = reporter in reporters ? reporters[reporter] : await _load(re
 const run = async () => {
     try {
         const perfObserver = new Performance(isObservePerf);
-        const { report, issues, counters, rules } = await main({
+        const { report, issues, counters, rules, configurationHints } = await main({
             cwd,
             tsConfigFile: tsConfig,
             gitignore: !isNoGitIgnore,
@@ -31,7 +31,7 @@ const run = async () => {
             isProduction,
             isShowProgress,
         });
-        await printReport({ report, issues, cwd, isProduction, options: reporterOptions });
+        await printReport({ report, issues, configurationHints, cwd, isProduction, options: reporterOptions });
         const totalErrorCount = Object.keys(report)
             .filter(reportGroup => report[reportGroup] && rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);

package/dist/constants.js

@@ -6,6 +6,7 @@ export const TEST_FILE_PATTERNS = [
     '**/{test,__tests__}/**/*.{js,jsx,ts,tsx,mjs,cjs}',
 ];
 export const IGNORED_GLOBAL_BINARIES = [
+    'bash',
     'bun',
     'deno',
     'git',
@@ -14,6 +15,7 @@ export const IGNORED_GLOBAL_BINARIES = [
     'npx',
     'pnpm',
     'yarn',
+    'cat',
     'cd',
     'cp',
     'echo',
@@ -49,6 +51,7 @@ export const ISSUE_TYPES = [
     'dependencies',
     'devDependencies',
     'unlisted',
+    'binaries',
     'unresolved',
     'exports',
     'nsExports',
@@ -63,6 +66,7 @@ export const ISSUE_TYPE_TITLE = {
     dependencies: 'Unused dependencies',
     devDependencies: 'Unused devDependencies',
     unlisted: 'Unlisted dependencies',
+    binaries: 'Unresolved binaries',
     unresolved: 'Unresolved imports',
     exports: 'Unused exports',
     nsExports: 'Unused exports in namespaces',

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export declare const main: (unresolvedConfiguration: CommandLineOptions) => Prom
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
     rules: import("./types/issues.js").Rules;
+    configurationHints: Set<unknown>;
 }>;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { _getDependenciesFromScripts } from './binaries/index.js';
+import { fromBinary, isBinary } from './binaries/util.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
@@ -47,14 +48,16 @@ export const main = async (unresolvedConfiguration) => {
             }
         }
         else {
-            if (isInNodeModules(specifier)) {
-                const packageName = getPackageNameFromFilePath(specifier);
-                const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
+            if (isBinary(specifier)) {
+                const binaryName = fromBinary(specifier);
+                const isHandled = deputy.maybeAddReferencedBinary(workspace, binaryName);
                 if (!isHandled)
-                    collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: packageName });
+                    collector.addIssue({ type: 'binaries', filePath: containingFilePath, symbol: binaryName });
             }
             else {
-                const packageName = getPackageNameFromModuleSpecifier(specifier);
+                const packageName = isInNodeModules(specifier)
+                    ? getPackageNameFromFilePath(specifier)
+                    : getPackageNameFromModuleSpecifier(specifier);
                 const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
                 if (!isHandled)
                     collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
@@ -296,12 +299,15 @@ export const main = async (unresolvedConfiguration) => {
         }
     }
     if (isReportDependencies) {
-        const { dependencyIssues, devDependencyIssues } = deputy.settleDependencyIssues();
+        const { dependencyIssues, devDependencyIssues, configurationHints } = deputy.settleDependencyIssues();
         dependencyIssues.forEach(issue => collector.addIssue(issue));
         if (!isProduction)
             devDependencyIssues.forEach(issue => collector.addIssue(issue));
+        configurationHints.forEach(hint => collector.addConfigurationHint(hint));
     }
-    const { issues, counters } = collector.getIssues();
+    const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
+    unusedIgnoredWorkspaces.forEach(identifier => collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier }));
+    const { issues, counters, configurationHints } = collector.getIssues();
     streamer.clear();
-    return { report, issues, counters, rules };
+    return { report, issues, counters, rules, configurationHints };
 };

package/dist/reporters/index.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    symbols: ({ report, issues }: import("../index.js").ReporterOptions) => void;
+    symbols: ({ report, issues, configurationHints }: import("../index.js").ReporterOptions) => void;
     compact: ({ report, issues }: import("../index.js").ReporterOptions) => void;
     codeowners: ({ report, issues, options }: import("../index.js").ReporterOptions) => void;
     json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;

package/dist/reporters/symbols.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues }: ReporterOptions) => void;
+declare const _default: ({ report, issues, configurationHints }: ReporterOptions) => void;
 export default _default;

package/dist/reporters/symbols.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import EasyTable from 'easy-table';
+import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { relative } from '../util/path.js';
 import { getTitle, logTitle, logIssueSet, identity } from './util.js';
 const TRUNCATE_WIDTH = 40;
@@ -16,7 +17,7 @@ const logIssueRecord = (issues) => {
     });
     console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());
 };
-export default ({ report, issues }) => {
+export default ({ report, issues, configurationHints }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
@@ -38,6 +39,15 @@ export default ({ report, issues }) => {
             totalIssues = totalIssues + issuesForType.length;
         }
     }
+    if (configurationHints.size > 0) {
+        logTitle('Configuration issues', configurationHints.size);
+        configurationHints.forEach(hint => {
+            const { type, workspaceName, identifier } = hint;
+            const message = `Unused item in ${type}`;
+            const workspace = workspaceName && workspaceName !== ROOT_WORKSPACE_NAME ? ` (workspace: ${workspaceName})` : ``;
+            console.warn(chalk.grey(`${message}${workspace}:`), identifier);
+        });
+    }
     if (totalIssues === 0) {
         console.log('✂️  Excellent, Knip found no issues.');
     }

package/dist/types/issues.d.ts

@@ -23,6 +23,7 @@ export type Issues = {
     dependencies: IssueRecords;
     devDependencies: IssueRecords;
     unlisted: IssueRecords;
+    binaries: IssueRecords;
     unresolved: IssueRecords;
     exports: IssueRecords;
     types: IssueRecords;
@@ -41,6 +42,7 @@ export type Counters = Record<IssueType | 'processed' | 'total', number>;
 export type ReporterOptions = {
     report: Report;
     issues: Issues;
+    configurationHints: ConfigurationHints;
     cwd: string;
     workingDir: string;
     isProduction: boolean;
@@ -49,3 +51,9 @@ export type ReporterOptions = {
 export type Reporter = (options: ReporterOptions) => void;
 export type IssueSeverity = 'error' | 'warn' | 'off';
 export type Rules = Record<IssueType, IssueSeverity>;
+export type ConfigurationHints = Set<ConfigurationHint>;
+export type ConfigurationHint = {
+    type: 'ignoreBinaries' | 'ignoreDependencies' | 'ignoreWorkspaces';
+    identifier: string;
+    workspaceName?: string;
+};

package/dist/typescript/getImportsAndExports.js

@@ -1,5 +1,6 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
+import { getOrSet } from '../util/map.js';
 import { isInNodeModules } from '../util/path.js';
 import { isDeclarationFileExtension, isAccessExpression, getAccessExpressionName } from './ast-helpers.js';
 import getExportVisitors from './visitors/exports/index.js';
@@ -22,17 +23,14 @@ export const getImportsAndExports = (sourceFile, options) => {
     const addInternalImport = ({ identifier, specifier, symbol, filePath, isDynamic }) => {
         const isStar = identifier === '*';
         const isReExported = Boolean(isStar && !symbol);
-        if (!internalImports.has(filePath)) {
-            internalImports.set(filePath, {
-                specifier,
-                isStar,
-                isReExported,
-                isReExportedBy: new Set(),
-                symbols: new Set(),
-                isDynamic,
-            });
-        }
-        const internalImport = internalImports.get(filePath);
+        const internalImport = getOrSet(internalImports, filePath, {
+            specifier,
+            isStar,
+            isReExported,
+            isReExportedBy: new Set(),
+            symbols: new Set(),
+            isDynamic,
+        });
         if (isReExported) {
             internalImport.isReExported = isReExported;
             internalImport.isReExportedBy.add(sourceFile.fileName);

package/dist/util/get-included-issue-types.js

@@ -1,7 +1,7 @@
 import { ISSUE_TYPES } from '../constants.js';
 export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
     if (cliArgs.dependencies) {
-        cliArgs.include = [...cliArgs.include, 'dependencies', 'unlisted', 'unresolved'];
+        cliArgs.include = [...cliArgs.include, 'dependencies', 'unlisted', 'binaries', 'unresolved'];
     }
     if (cliArgs.exports) {
         const exports = ['exports', 'nsExports', 'classMembers', 'types', 'nsTypes', 'enumMembers', 'duplicates'];

package/dist/util/glob.js

@@ -16,9 +16,13 @@ export const hasNoProductionSuffix = (pattern) => !pattern.endsWith('!');
 const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore = true }) => {
+    if (patterns.length === 0)
+        return [];
     const relativePath = relative(cwd, workingDir);
     const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
     const globPatterns = compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
+    if (globPatterns[0].startsWith('!'))
+        return [];
     const ignorePatterns = compact([...ignore, '**/node_modules/**']);
     debugLogObject(`Globbing (${relativePath || ROOT_WORKSPACE_NAME})`, { cwd, globPatterns, ignorePatterns });
     return globby(globPatterns, {
@@ -29,12 +33,16 @@ const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore =
         dot: true,
     });
 };
-const pureGlob = async ({ cwd, patterns, ignore = [], gitignore = true }) => globby(patterns, {
-    cwd,
-    ignore: [...ignore, '**/node_modules/**'],
-    gitignore,
-    absolute: true,
-});
+const pureGlob = async ({ cwd, patterns, ignore = [], gitignore = true }) => {
+    if (patterns.length === 0)
+        return [];
+    return globby(patterns, {
+        cwd,
+        ignore: [...ignore, '**/node_modules/**'],
+        gitignore,
+        absolute: true,
+    });
+};
 const firstGlob = async ({ cwd, patterns }) => {
     const stream = fg.stream(patterns.map(removeProductionSuffix), { cwd, ignore: ['**/node_modules/**'] });
     for await (const entry of stream) {

package/dist/util/map.d.ts

@@ -0,0 +1 @@
+export declare const getOrSet: <K extends string, V, T extends Map<K, V>>(map: T, key: K, value: V) => NonNullable<V>;

package/dist/util/map.js

@@ -0,0 +1,6 @@
+export const getOrSet = (map, key, value) => {
+    if (!map.has(key)) {
+        map.set(key, value);
+    }
+    return map.get(key);
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.7.0";
+export declare const version = "2.8.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.7.0';
+export const version = '2.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -74,7 +74,7 @@
     "@typescript-eslint/parser": "5.57.1",
     "c8": "7.13.0",
     "eslint": "8.37.0",
-    "eslint-import-resolver-typescript": "3.5.4",
+    "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-n": "15.7.0",
     "globstar": "1.0.0",
@@ -83,7 +83,7 @@
     "remark-cli": "11.0.0",
     "remark-preset-webpro": "0.0.2",
     "tsx": "3.12.6",
-    "type-fest": "3.7.2"
+    "type-fest": "3.8.0"
   },
   "engines": {
     "node": ">=16.17.0 <17 || >=18.6.0"