knip 5.65.0 → 5.66.1

package/dist/ConfigurationChief.d.ts

@@ -147,6 +147,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        danger?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'dependency-cruiser'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -639,13 +644,18 @@ export declare class ConfigurationChief {
         ignoreUnresolved: (string | RegExp)[];
     };
     getConfigForWorkspace(workspaceName: string, extensions?: string[]): {
+        bun?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        pnpm?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         angular?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ava?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         babel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         biome?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         bumpp?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        bun?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         capacitor?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         changelogen?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -658,6 +668,7 @@ export declare class ConfigurationChief {
         cspell?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         cucumber?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         cypress?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        danger?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "dependency-cruiser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         docusaurus?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         dotenv?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -673,7 +684,6 @@ export declare class ConfigurationChief {
         hardhat?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         husky?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "i18next-parser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ladle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         lefthook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -690,7 +700,6 @@ export declare class ConfigurationChief {
         nest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         netlify?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "node-modules-inspector"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         nodemon?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "npm-package-json-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -703,7 +712,6 @@ export declare class ConfigurationChief {
         "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         plop?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        pnpm?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         postcss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         preconstruct?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         prettier?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -738,7 +746,6 @@ export declare class ConfigurationChief {
         tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         typedoc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         unbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         unocss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "vercel-og"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -751,7 +758,6 @@ export declare class ConfigurationChief {
         wireit?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         wrangler?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         xo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         yorkie?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         entry: string[];
         project: string[];

package/dist/ConfigurationChief.js

@@ -98,6 +98,7 @@ export class ConfigurationChief {
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
         const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
+        const ignoreIssues = rawConfig.ignoreIssues;
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
         const { syncCompilers, asyncCompilers } = rawConfig;
@@ -115,6 +116,7 @@ export class ConfigurationChief {
             ignoreMembers,
             ignoreUnresolved,
             ignoreExportsUsedInFile,
+            ignoreIssues,
             ignoreWorkspaces,
             isIncludeEntryExports,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),

package/dist/ConsoleStreamer.d.ts

@@ -1,10 +1,11 @@
 import type { MainOptions } from './util/create-options.js';
 export declare class ConsoleStreamer {
     isEnabled: boolean;
+    isWatch: boolean;
     private lines;
     constructor(options: MainOptions);
     private clearLines;
-    private resetLines;
+    private clearScreen;
     private update;
     cast(message: string | string[], sub?: string): void;
     clear(): void;

package/dist/ConsoleStreamer.js

@@ -1,8 +1,10 @@
 export class ConsoleStreamer {
     isEnabled = false;
+    isWatch = false;
     lines = 0;
     constructor(options) {
-        this.isEnabled = options.isShowProgress;
+        this.isEnabled = options.isShowProgress && !options.isDebug;
+        this.isWatch = options.isWatch;
     }
     clearLines(count) {
         if (count > 0) {
@@ -13,11 +15,11 @@ export class ConsoleStreamer {
         }
         process.stdout.cursorTo(0);
     }
-    resetLines() {
-        this.clearLines(this.lines);
+    clearScreen() {
+        process.stdout.write('\x1b[2J\x1b[1;1f');
     }
     update(messages) {
-        this.resetLines();
+        this.clear();
         process.stdout.write(`${messages.join('\n')}\n`);
         this.lines = messages.length;
     }
@@ -32,6 +34,9 @@ export class ConsoleStreamer {
     clear() {
         if (!this.isEnabled)
             return;
-        this.resetLines();
+        if (this.isWatch)
+            this.clearScreen();
+        else
+            this.clearLines(this.lines);
     }
 }

package/dist/IssueCollector.d.ts

@@ -1,3 +1,4 @@
+import type { IgnoreIssues } from './types/config.js';
 import type { ConfigurationHint, Issue, TagHint } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
 export declare class IssueCollector {
@@ -13,15 +14,18 @@ export declare class IssueCollector {
     private ignoreFilesPatterns;
     private isMatch;
     private isFileMatch;
+    private issueMatchers;
     constructor(options: MainOptions);
     addIgnorePatterns(patterns: string[]): void;
     addIgnoreFilesPatterns(patterns: string[]): void;
+    setIgnoreIssues(ignoreIssues?: IgnoreIssues): void;
+    private shouldIgnoreIssue;
     addFileCounts({ processed, unused }: {
         processed: number;
         unused: number;
     }): void;
     addFilesIssues(filePaths: string[]): void;
-    addIssue(issue: Issue): Issue | undefined;
+    addIssue(issue: Issue): true | undefined;
     addConfigurationHint(issue: ConfigurationHint): void;
     addTagHint(issue: TagHint): void;
     purge(): import("./types/issues.js").IssueSet;
@@ -31,4 +35,7 @@ export declare class IssueCollector {
         tagHints: Set<TagHint>;
         configurationHints: Set<ConfigurationHint>;
     };
+    private retainedIssues;
+    retainIssue(issue: Issue): void;
+    getRetainedIssues(): Issue[];
 }

package/dist/IssueCollector.js

@@ -16,6 +16,7 @@ export class IssueCollector {
     ignoreFilesPatterns = new Set();
     isMatch;
     isFileMatch;
+    issueMatchers = new Map();
     constructor(options) {
         this.cwd = options.cwd;
         this.rules = options.rules;
@@ -26,14 +27,37 @@ export class IssueCollector {
     addIgnorePatterns(patterns) {
         for (const pattern of patterns)
             this.ignorePatterns.add(pattern);
-        const _patterns = Array.from(this.ignorePatterns);
-        this.isMatch = (filePath) => isMatch(filePath, _patterns, { dot: true });
+        const p = [...this.ignorePatterns];
+        this.isMatch = (filePath) => isMatch(filePath, p, { dot: true });
     }
     addIgnoreFilesPatterns(patterns) {
         for (const pattern of patterns)
             this.ignoreFilesPatterns.add(pattern);
-        const _patterns = Array.from(this.ignoreFilesPatterns);
-        this.isFileMatch = (filePath) => isMatch(filePath, _patterns, { dot: true });
+        const p = [...this.ignoreFilesPatterns];
+        this.isFileMatch = (filePath) => isMatch(filePath, p, { dot: true });
+    }
+    setIgnoreIssues(ignoreIssues) {
+        if (!ignoreIssues)
+            return;
+        const issueTypePatterns = new Map();
+        for (const [pattern, issueTypes] of Object.entries(ignoreIssues)) {
+            for (const issueType of issueTypes) {
+                if (!issueTypePatterns.has(issueType)) {
+                    issueTypePatterns.set(issueType, []);
+                }
+                issueTypePatterns.get(issueType)?.push(pattern);
+            }
+        }
+        for (const [issueType, patterns] of issueTypePatterns) {
+            this.issueMatchers.set(issueType, (filePath) => isMatch(filePath, patterns, { dot: true }));
+        }
+    }
+    shouldIgnoreIssue(filePath, issueType) {
+        const matcher = this.issueMatchers.get(issueType);
+        if (!matcher)
+            return false;
+        const relativePath = relative(this.cwd, filePath);
+        return matcher(relativePath);
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -49,6 +73,8 @@ export class IssueCollector {
                 continue;
             if (this.isFileMatch(filePath))
                 continue;
+            if (this.shouldIgnoreIssue(filePath, 'files'))
+                continue;
             this.issues.files.add(filePath);
             const symbol = relative(this.cwd, filePath);
             this.issues._files[symbol] = [{ type: 'files', filePath, symbol, severity: this.rules.files }];
@@ -61,6 +87,8 @@ export class IssueCollector {
             return;
         if (this.isMatch(issue.filePath))
             return;
+        if (this.shouldIgnoreIssue(issue.filePath, issue.type))
+            return;
         const key = relative(this.cwd, issue.filePath);
         const { type } = issue;
         issue.severity = this.rules[type];
@@ -71,7 +99,7 @@ export class IssueCollector {
             issues[key][symbol] = issue;
             this.counters[issue.type]++;
         }
-        return issue;
+        return true;
     }
     addConfigurationHint(issue) {
         const key = `${issue.workspaceName}::${issue.type}::${issue.identifier}`;
@@ -95,4 +123,11 @@ export class IssueCollector {
             configurationHints: new Set(this.configurationHints.values()),
         };
     }
+    retainedIssues = [];
+    retainIssue(issue) {
+        this.retainedIssues.push(issue);
+    }
+    getRetainedIssues() {
+        return this.retainedIssues;
+    }
 }

package/dist/compilers/index.d.ts

@@ -99,6 +99,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    danger?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     'dependency-cruiser'?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -670,6 +675,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        danger?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'dependency-cruiser'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1156,10 +1166,10 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
-    include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
-    exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers")[] | undefined;
+    include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
+    exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
+    rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates", "error" | "warn" | "off">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -1169,14 +1179,8 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreDependencies?: (string | RegExp)[] | undefined;
     ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreUnresolved?: (string | RegExp)[] | undefined;
-    ignoreExportsUsedInFile?: boolean | {
-        class?: boolean | undefined;
-        enum?: boolean | undefined;
-        function?: boolean | undefined;
-        interface?: boolean | undefined;
-        member?: boolean | undefined;
-        type?: boolean | undefined;
-    } | undefined;
+    ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
+    ignoreIssues?: Record<string, ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[]> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, true | ((filename: string, contents: string) => string) | ((filename: string, contents: string) => Promise<string>)> | undefined;

package/dist/constants.d.ts

@@ -1,4 +1,3 @@
-import type { IssueType } from './types/issues.js';
 export declare const ROOT_WORKSPACE_NAME = ".";
 export declare const IMPORT_STAR = "*";
 export declare const ANONYMOUS = "__anonymous";
@@ -16,8 +15,34 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: IssueType[];
-export declare const ISSUE_TYPE_TITLE: Record<IssueType, string>;
+export declare const ISSUE_TYPES: readonly ["files", "dependencies", "devDependencies", "optionalPeerDependencies", "unlisted", "binaries", "unresolved", "exports", "nsExports", "types", "nsTypes", "enumMembers", "classMembers", "duplicates"];
+export declare const ISSUE_TYPE_TITLE: {
+    readonly files: "Unused files";
+    readonly _files: "Unused files";
+    readonly dependencies: "Unused dependencies";
+    readonly devDependencies: "Unused devDependencies";
+    readonly optionalPeerDependencies: "Referenced optional peerDependencies";
+    readonly unlisted: "Unlisted dependencies";
+    readonly binaries: "Unlisted binaries";
+    readonly unresolved: "Unresolved imports";
+    readonly exports: "Unused exports";
+    readonly nsExports: "Exports in used namespace";
+    readonly types: "Unused exported types";
+    readonly nsTypes: "Exported types in used namespace";
+    readonly enumMembers: "Unused exported enum members";
+    readonly classMembers: "Unused exported class members";
+    readonly duplicates: "Duplicate exports";
+};
+export declare const SYMBOL_TYPE: {
+    readonly CLASS: "class";
+    readonly ENUM: "enum";
+    readonly FUNCTION: "function";
+    readonly INTERFACE: "interface";
+    readonly MEMBER: "member";
+    readonly TYPE: "type";
+    readonly UNKNOWN: "unknown";
+    readonly VARIABLE: "variable";
+};
 export declare const FIX_FLAGS: {
     readonly NONE: 0;
     readonly OBJECT_BINDING: number;

package/dist/constants.js

@@ -190,6 +190,16 @@ export const ISSUE_TYPE_TITLE = {
     classMembers: 'Unused exported class members',
     duplicates: 'Duplicate exports',
 };
+export const SYMBOL_TYPE = {
+    CLASS: 'class',
+    ENUM: 'enum',
+    FUNCTION: 'function',
+    INTERFACE: 'interface',
+    MEMBER: 'member',
+    TYPE: 'type',
+    UNKNOWN: 'unknown',
+    VARIABLE: 'variable',
+};
 export const FIX_FLAGS = {
     NONE: 0,
     OBJECT_BINDING: 1 << 0,

package/dist/graph/build.js

@@ -18,7 +18,8 @@ export async function build({ chief, collector, deputy, factory, isGitIgnored, s
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const toSourceFilePaths = getToSourcePathsHandler(chief);
-    const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
+    const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
+    const getReferencedInternalFilePath = getReferencedInputsHandler(deputy, chief, isGitIgnored, addIssue);
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);

package/dist/index.js

@@ -8,6 +8,7 @@ import { build } from './graph/build.js';
 import { IssueCollector } from './IssueCollector.js';
 import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
+import watchReporter from './reporters/watch.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
@@ -24,6 +25,7 @@ export const main = async (options) => {
     streamer.cast('Reading workspace configuration');
     const workspaces = await chief.getWorkspaces();
     const isGitIgnored = await getGitIgnoredHandler(options);
+    collector.setIgnoreIssues(chief.config.ignoreIssues);
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
     debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
     const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
@@ -51,6 +53,9 @@ export const main = async (options) => {
     });
     if (options.isWatch) {
         const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
+        const onUpdate = options.isWatch
+            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
+            : () => { };
         const watchHandler = await getWatchHandler(options, {
             analyzedFiles,
             analyzeSourceFile,
@@ -60,7 +65,7 @@ export const main = async (options) => {
             factory,
             graph,
             isIgnored,
-            streamer,
+            onUpdate,
             unreferencedFiles,
         });
         watch('.', { recursive: true }, watchHandler);

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

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

package/dist/plugins/danger/index.js

@@ -0,0 +1,11 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Danger';
+const enablers = ['danger'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['dangerfile.{js,cjs,mjs,ts}'];
+export default {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+};

package/dist/plugins/eleventy/helpers.d.ts

@@ -82,6 +82,7 @@ export declare class DummyEleventyConfig {
     setLayoutsDirectory(): void;
     setFreezeReservedData(): void;
     addDateParsing(): void;
+    addBundle(): void;
     _uniqueId: {};
     events: {};
     benchmarkManager: {};

package/dist/plugins/eleventy/helpers.js

@@ -91,6 +91,7 @@ export class DummyEleventyConfig {
     setLayoutsDirectory() { }
     setFreezeReservedData() { }
     addDateParsing() { }
+    addBundle() { }
     _uniqueId = {};
     events = {};
     benchmarkManager = {};

package/dist/plugins/index.d.ts

@@ -141,6 +141,12 @@ export declare const Plugins: {
         entry: string[];
         resolveConfig: import("../types/config.js").ResolveConfig<import("./cypress/types.js").CypressConfig>;
     };
+    danger: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        entry: string[];
+    };
     'dependency-cruiser': {
         title: string;
         enablers: string[];

package/dist/plugins/index.js

@@ -17,6 +17,7 @@ import { default as createTypescriptApp } from './create-typescript-app/index.js
 import { default as cspell } from './cspell/index.js';
 import { default as cucumber } from './cucumber/index.js';
 import { default as cypress } from './cypress/index.js';
+import { default as danger } from './danger/index.js';
 import { default as dependencyCruiser } from './dependency-cruiser/index.js';
 import { default as docusaurus } from './docusaurus/index.js';
 import { default as dotenv } from './dotenv/index.js';
@@ -132,6 +133,7 @@ export const Plugins = {
     cspell,
     cucumber,
     cypress,
+    danger,
     'dependency-cruiser': dependencyCruiser,
     docusaurus,
     dotenv,

package/dist/plugins/nuxt/index.js

@@ -18,7 +18,11 @@ const production = [
 ];
 const setup = async () => {
     if (globalThis && !('defineNuxtConfig' in globalThis)) {
-        Object.defineProperty(globalThis, 'defineNuxtConfig', { value: (id) => id });
+        Object.defineProperty(globalThis, 'defineNuxtConfig', {
+            value: (id) => id,
+            writable: true,
+            configurable: true,
+        });
     }
 };
 const resolveConfig = async (localConfig) => {

package/dist/reporters/util/util.d.ts

@@ -1,9 +1,9 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import { type Issue, type IssueSeverity, type IssueSymbol } from '../../types/issues.js';
+import type { Issue, IssueSeverity, IssueSymbol } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
-export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
+export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => "Unused files" | "Unused dependencies" | "Unused devDependencies" | "Referenced optional peerDependencies" | "Unlisted dependencies" | "Unlisted binaries" | "Unresolved imports" | "Unused exports" | "Exports in used namespace" | "Unused exported types" | "Exported types in used namespace" | "Unused exported enum members" | "Unused exported class members" | "Duplicate exports";
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;
 type LogIssueLine = {

package/dist/reporters/util/util.js

@@ -1,6 +1,5 @@
 import picocolors from 'picocolors';
-import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import { SymbolType } from '../../types/issues.js';
+import { ISSUE_TYPE_TITLE, SYMBOL_TYPE } from '../../constants.js';
 import { relative } from '../../util/path.js';
 import { Table } from '../../util/table.js';
 const plain = (text) => text;
@@ -47,7 +46,7 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
         const symbol = issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol;
         table.cell('symbol', print(symbol), options.isUseColors ? highlightSymbol(issue) : () => symbol);
         table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));
-        table.cell('symbolType', issue.symbolType && issue.symbolType !== SymbolType.UNKNOWN && print(issue.symbolType));
+        table.cell('symbolType', issue.symbolType && issue.symbolType !== SYMBOL_TYPE.UNKNOWN && print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
         const cell = issue.type === 'files' ? '' : `${relative(cwd, issue.filePath)}${pos}`;
         table.cell('filePath', print(cell));

package/dist/reporters/watch.d.ts

@@ -4,8 +4,8 @@ import type { MainOptions } from '../util/create-options.js';
 interface WatchReporter {
     issues: Issues;
     streamer: ConsoleStreamer;
-    startTime?: number;
+    duration?: number;
     size: number;
 }
-declare const _default: (options: MainOptions, { issues, streamer, startTime, size }: WatchReporter) => void;
+declare const _default: (options: MainOptions, { issues, streamer, duration, size }: WatchReporter) => void;
 export default _default;

package/dist/reporters/watch.js

@@ -2,7 +2,7 @@ import picocolors from 'picocolors';
 import { perfObserver } from '../util/Performance.js';
 import { prettyMilliseconds } from '../util/string.js';
 import { getIssueTypeTitle, getTableForType } from './util/util.js';
-export default (options, { issues, streamer, startTime, size }) => {
+export default (options, { issues, streamer, duration, size }) => {
     const reportMultipleGroups = Object.values(options.includedIssueTypes).filter(Boolean).length > 1;
     let totalIssues = 0;
     const lines = [];
@@ -22,8 +22,8 @@ export default (options, { issues, streamer, startTime, size }) => {
         }
     }
     const mem = perfObserver.getCurrentMemUsageInMb();
-    const duration = perfObserver.getCurrentDurationInMs(startTime);
-    const summary = `${size} files in ${prettyMilliseconds(duration)} (${mem}MB)`;
+    const ms = duration ?? perfObserver.getCurrentDurationInMs();
+    const summary = `${size} files in ${prettyMilliseconds(ms)} (${mem}MB)`;
     const messages = totalIssues === 0
         ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
         : [...lines, '', picocolors.gray(summary)];

package/dist/schema/configuration.d.ts

@@ -97,6 +97,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    danger: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     'dependency-cruiser': z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -668,6 +673,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        danger: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         'dependency-cruiser': z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1172,13 +1182,9 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     ignoreMembers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
     ignoreExportsUsedInFile: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
-        class: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        enum: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        function: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        interface: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        member: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-        type: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        [k: string]: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>]>>;
+    ignoreIssues: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"classMembers">]>>>>;
     ignoreWorkspaces: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     includeEntryExports: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     compilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<SyncCompiler, SyncCompiler>]>, z.ZodMiniCustom<AsyncCompiler, AsyncCompiler>]>>>;