knip 5.65.0 → 5.66.1

package/dist/schema/configuration.js

@@ -1,4 +1,5 @@
 import { z } from 'zod/mini';
+import { SYMBOL_TYPE } from '../constants.js';
 import { globSchema, pluginsSchema } from './plugins.js';
 const pathsSchema = z.record(z.string(), z.array(z.string()));
 const syncCompilerSchema = z.union([z.literal(true), z.custom()]);
@@ -23,15 +24,10 @@ const issueTypeSchema = z.union([
     z.literal('classMembers'),
 ]);
 const rulesSchema = z.partialRecord(issueTypeSchema, z.enum(['error', 'warn', 'off']));
-const ignoreExportsUsedInFileObjectSchema = z.strictObject({
-    class: z.optional(z.boolean()),
-    enum: z.optional(z.boolean()),
-    function: z.optional(z.boolean()),
-    interface: z.optional(z.boolean()),
-    member: z.optional(z.boolean()),
-    type: z.optional(z.boolean()),
-});
+const ignorableSymbolTypes = Object.values(SYMBOL_TYPE).filter(type => type !== 'unknown');
+const ignoreExportsUsedInFileObjectSchema = z.strictObject(Object.fromEntries(ignorableSymbolTypes.map(type => [type, z.optional(z.boolean())])));
 const ignoreExportsUsedInFileSchema = z.union([z.boolean(), ignoreExportsUsedInFileObjectSchema]);
+const ignoreIssuesSchema = z.record(z.string(), z.array(issueTypeSchema));
 const rootConfigurationSchema = z.object({
     $schema: z.optional(z.string()),
     rules: z.optional(rulesSchema),
@@ -45,6 +41,7 @@ const rootConfigurationSchema = z.object({
     ignoreMembers: z.optional(stringOrRegexSchema),
     ignoreUnresolved: z.optional(stringOrRegexSchema),
     ignoreExportsUsedInFile: z.optional(ignoreExportsUsedInFileSchema),
+    ignoreIssues: z.optional(ignoreIssuesSchema),
     ignoreWorkspaces: z.optional(z.array(z.string())),
     includeEntryExports: z.optional(z.boolean()),
     compilers: z.optional(compilersSchema),

package/dist/schema/plugins.d.ts

@@ -101,6 +101,11 @@ export declare const pluginsSchema: 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.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.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>>]>>;

package/dist/schema/plugins.js

@@ -29,6 +29,7 @@ export const pluginsSchema = z.object({
     cspell: pluginSchema,
     cucumber: pluginSchema,
     cypress: pluginSchema,
+    danger: pluginSchema,
     'dependency-cruiser': pluginSchema,
     docusaurus: pluginSchema,
     dotenv: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
-export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "syncpack", "tailwind", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];
+export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "danger", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "syncpack", "tailwind", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];

package/dist/types/PluginNames.js

@@ -18,6 +18,7 @@ export const pluginNames = [
     'cspell',
     'cucumber',
     'cypress',
+    'danger',
     'dependency-cruiser',
     'docusaurus',
     'dotenv',

package/dist/types/config.d.ts

@@ -5,7 +5,7 @@ import type { knipConfigurationSchema } from '../schema/configuration.js';
 import type { pluginSchema } from '../schema/plugins.js';
 import type { Input } from '../util/input.js';
 import type { Args } from './args.js';
-import type { SymbolType } from './issues.js';
+import type { IssueType, SymbolType } from './issues.js';
 import type { Tags } from './options.js';
 import type { PluginName } from './PluginNames.js';
 import type { PackageJson } from './package-json.js';
@@ -23,8 +23,9 @@ export type BinaryResolver = (binary: string, args: string[], options: BinaryRes
 export type RawConfiguration = z.infer<typeof knipConfigurationSchema>;
 export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
 export type IgnorePatterns = (string | RegExp)[];
-type IgnorableExport = Exclude<SymbolType, SymbolType.UNKNOWN>;
+type IgnorableExport = Exclude<SymbolType, 'unknown'>;
 export type IgnoreExportsUsedInFile = boolean | Partial<Record<IgnorableExport, boolean>>;
+export type IgnoreIssues = Record<string, IssueType[]>;
 export type GetImportsAndExportsOptions = {
     skipTypeOnly: boolean;
     isFixExports: boolean;
@@ -38,6 +39,7 @@ export interface Configuration {
     ignoreBinaries: IgnorePatterns;
     ignoreDependencies: IgnorePatterns;
     ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
+    ignoreIssues?: IgnoreIssues;
     ignoreMembers: IgnorePatterns;
     ignoreUnresolved: IgnorePatterns;
     ignoreWorkspaces: string[];

package/dist/types/issues.d.ts

@@ -1,13 +1,5 @@
-export declare enum SymbolType {
-    VARIABLE = "variable",
-    TYPE = "type",
-    INTERFACE = "interface",
-    ENUM = "enum",
-    FUNCTION = "function",
-    CLASS = "class",
-    MEMBER = "member",
-    UNKNOWN = "unknown"
-}
+import type { SYMBOL_TYPE } from '../constants.js';
+export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
 export type IssueSymbol = {
     symbol: string;
     pos?: number;

package/dist/types/issues.js

@@ -1,11 +1 @@
-export var SymbolType;
-(function (SymbolType) {
-    SymbolType["VARIABLE"] = "variable";
-    SymbolType["TYPE"] = "type";
-    SymbolType["INTERFACE"] = "interface";
-    SymbolType["ENUM"] = "enum";
-    SymbolType["FUNCTION"] = "function";
-    SymbolType["CLASS"] = "class";
-    SymbolType["MEMBER"] = "member";
-    SymbolType["UNKNOWN"] = "unknown";
-})(SymbolType || (SymbolType = {}));
+export {};

package/dist/typescript/ast-helpers.d.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import type { Fix } from '../types/exports.js';
-import { SymbolType } from '../types/issues.js';
+import type { SymbolType } from '../types/issues.js';
 export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): boolean;
 export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpression;
 export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
@@ -12,14 +12,14 @@ export declare const getClassMember: (member: ts.MethodDeclaration | ts.Property
     node: ts.MethodDeclaration | ts.PropertyDeclaration;
     identifier: string;
     pos: number;
-    type: SymbolType;
+    type: "member";
     fix: Fix;
 };
 export declare const getEnumMember: (member: ts.EnumMember, isFixTypes: boolean) => {
     node: ts.EnumMember;
     identifier: string;
     pos: number;
-    type: SymbolType;
+    type: "member";
     fix: Fix;
 };
 export declare function stripQuotes(name: string): string;

package/dist/typescript/ast-helpers.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../constants.js';
-import { SymbolType } from '../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../constants.js';
 function isGetOrSetAccessorDeclaration(node) {
     return node.kind === ts.SyntaxKind.SetAccessor || node.kind === ts.SyntaxKind.GetAccessor;
 }
@@ -34,20 +33,20 @@ export function isPropertyAccessCall(node, identifier) {
 }
 export const getNodeType = (node) => {
     if (!node)
-        return SymbolType.UNKNOWN;
+        return SYMBOL_TYPE.UNKNOWN;
     if (ts.isFunctionDeclaration(node))
-        return SymbolType.FUNCTION;
+        return SYMBOL_TYPE.FUNCTION;
     if (ts.isClassDeclaration(node))
-        return SymbolType.CLASS;
+        return SYMBOL_TYPE.CLASS;
     if (ts.isInterfaceDeclaration(node))
-        return SymbolType.INTERFACE;
+        return SYMBOL_TYPE.INTERFACE;
     if (ts.isTypeAliasDeclaration(node))
-        return SymbolType.TYPE;
+        return SYMBOL_TYPE.TYPE;
     if (ts.isEnumDeclaration(node))
-        return SymbolType.ENUM;
+        return SYMBOL_TYPE.ENUM;
     if (ts.isVariableDeclaration(node))
-        return SymbolType.VARIABLE;
-    return SymbolType.UNKNOWN;
+        return SYMBOL_TYPE.VARIABLE;
+    return SYMBOL_TYPE.UNKNOWN;
 };
 export const isNonPrivatePropertyOrMethodDeclaration = (member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || isGetOrSetAccessorDeclaration(member)) &&
     !isPrivateMember(member);
@@ -55,14 +54,14 @@ export const getClassMember = (member, isFixTypes) => ({
     node: member,
     identifier: member.name.getText(),
     pos: member.name.getStart() + (ts.isComputedPropertyName(member.name) ? 1 : 0),
-    type: SymbolType.MEMBER,
+    type: SYMBOL_TYPE.MEMBER,
     fix: isFixTypes ? [member.getStart(), member.getEnd(), FIX_FLAGS.NONE] : undefined,
 });
 export const getEnumMember = (member, isFixTypes) => ({
     node: member,
     identifier: stripQuotes(member.name.getText()),
     pos: member.name.getStart(),
-    type: SymbolType.MEMBER,
+    type: SYMBOL_TYPE.MEMBER,
     fix: isFixTypes
         ? [member.getStart(), member.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.WITH_NEWLINE]
         : undefined,

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -1,12 +1,11 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { isModule } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
     if (ts.isExportDeclaration(node)) {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-            const nodeType = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
+            const nodeType = node.isTypeOnly ? SYMBOL_TYPE.TYPE : SYMBOL_TYPE.UNKNOWN;
             const sourceFile = node.getSourceFile();
             const declarations = sourceFile.getNamedDeclarations?.();
             return node.exportClause.elements.map(element => {
@@ -14,8 +13,8 @@ export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
                 const propName = element.propertyName?.text;
                 const symbol = declarations?.get(propName ?? identifier)?.[0]?.symbol;
                 const pos = element.name.pos;
-                const type = element.isTypeOnly ? SymbolType.TYPE : nodeType;
-                const fix = (isFixExports && type !== SymbolType.TYPE) || (isFixTypes && type === SymbolType.TYPE)
+                const type = element.isTypeOnly ? SYMBOL_TYPE.TYPE : nodeType;
+                const fix = (isFixExports && type !== SYMBOL_TYPE.TYPE) || (isFixTypes && type === SYMBOL_TYPE.TYPE)
                     ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.EMPTY_DECLARATION]
                     : undefined;
                 return { node: element, symbol, identifier, type, pos, fix };

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { compact } from '../../../util/array.js';
 import { getClassMember, getDefaultKeywordNode, getEnumMember, getExportKeywordNode, isNonPrivatePropertyOrMethodDeclaration, } from '../../ast-helpers.js';
 import { isModule } from '../helpers.js';
@@ -20,7 +19,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 node: element,
                                 symbol: element.symbol,
                                 identifier: element.name.escapedText.toString(),
-                                type: SymbolType.UNKNOWN,
+                                type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.name.getStart(),
                                 fix,
                             };
@@ -35,7 +34,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 node: element,
                                 symbol: element.symbol,
                                 identifier: element.getText(),
-                                type: SymbolType.UNKNOWN,
+                                type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.getStart(),
                                 fix,
                             };
@@ -45,7 +44,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                 const identifier = declaration.name.getText();
                 const pos = declaration.name.getStart();
                 const fix = getFix(exportKeyword);
-                return { node: declaration, identifier, type: SymbolType.UNKNOWN, pos, fix };
+                return { node: declaration, identifier, type: SYMBOL_TYPE.UNKNOWN, pos, fix };
             });
         }
         const defaultKeyword = getDefaultKeywordNode(node);
@@ -53,7 +52,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node.body ?? node).getStart();
             const fix = getFix(exportKeyword, defaultKeyword);
-            return { node, identifier, pos, type: SymbolType.FUNCTION, fix };
+            return { node, identifier, pos, type: SYMBOL_TYPE.FUNCTION, fix };
         }
         if (ts.isClassDeclaration(node) && node.name) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
@@ -62,26 +61,26 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
             const members = isReportClassMembers
                 ? node.members.filter(isNonPrivatePropertyOrMethodDeclaration).map(member => getClassMember(member, isFixTypes))
                 : [];
-            return { node, identifier, type: SymbolType.CLASS, pos, members, fix };
+            return { node, identifier, type: SYMBOL_TYPE.CLASS, pos, members, fix };
         }
         if (ts.isTypeAliasDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SymbolType.TYPE, pos, fix };
+            return { node, identifier, type: SYMBOL_TYPE.TYPE, pos, fix };
         }
         if (ts.isInterfaceDeclaration(node)) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SymbolType.INTERFACE, pos, fix };
+            return { node, identifier, type: SYMBOL_TYPE.INTERFACE, pos, fix };
         }
         if (ts.isEnumDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
             const members = node.members.map(member => getEnumMember(member, isFixExports));
-            return { node, identifier, type: SymbolType.ENUM, pos, members, fix };
+            return { node, identifier, type: SYMBOL_TYPE.ENUM, pos, members, fix };
         }
     }
 });

package/dist/typescript/visitors/exports/exportsAccessExpression.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isJS, (node, { isFixExports }) => {
@@ -12,7 +11,7 @@ export default visit(isJS, (node, { isFixExports }) => {
             return {
                 node: node.left.name,
                 identifier,
-                type: SymbolType.UNKNOWN,
+                type: SYMBOL_TYPE.UNKNOWN,
                 pos,
                 fix,
             };

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -1,6 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { SymbolType } from '../../../types/issues.js';
+import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { hasRequireCall, isModuleExportsAccess, stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
@@ -16,7 +15,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                     return {
                         node: node.expression.left.name,
                         identifier,
-                        type: SymbolType.UNKNOWN,
+                        type: SYMBOL_TYPE.UNKNOWN,
                         pos,
                         fix,
                     };
@@ -26,13 +25,13 @@ export default visit(isJS, (node, { isFixExports }) => {
                     if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
                         return expr.properties.map(node => {
                             const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
-                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.getStart(), fix };
+                            return { node, identifier: node.getText(), type: SYMBOL_TYPE.UNKNOWN, pos: node.getStart(), fix };
                         });
                     }
                     if (ts.isCallExpression(node.expression.right) && hasRequireCall(node.expression.right)) {
                         return;
                     }
-                    return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos + 1, fix: undefined };
+                    return { node, identifier: 'default', type: SYMBOL_TYPE.UNKNOWN, pos: expr.pos + 1, fix: undefined };
                 }
             }
             else if (ts.isElementAccessExpression(node.expression.left) &&
@@ -45,7 +44,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                 return {
                     node: node.expression.left.argumentExpression,
                     identifier,
-                    type: SymbolType.UNKNOWN,
+                    type: SYMBOL_TYPE.UNKNOWN,
                     pos,
                     fix,
                 };

package/dist/util/Performance.d.ts

@@ -34,7 +34,7 @@ declare class Performance {
     getTimerifiedFunctionsTable(): string;
     addMemoryMark(index: number): void;
     getMemoryUsageTable(): string;
-    getCurrentDurationInMs(startTime?: number): number;
+    getCurrentDurationInMs(): number;
     getMemHeapUsage(): number;
     getCurrentMemUsageInMb(): any;
     finalize(): Promise<void>;

package/dist/util/Performance.js

@@ -133,8 +133,8 @@ class Performance {
         }
         return table.toString();
     }
-    getCurrentDurationInMs(startTime) {
-        return performance.now() - (startTime ?? this.startTime);
+    getCurrentDurationInMs() {
+        return performance.now() - this.startTime;
     }
     getMemHeapUsage() {
         return (memoryUsage().heapUsed ?? 0) - (this.memoryUsageStart?.heapUsed ?? 0);

package/dist/util/create-options.d.ts

@@ -133,6 +133,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             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;
@@ -704,6 +709,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 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;
@@ -1190,10 +1200,10 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             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;
@@ -1203,14 +1213,8 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         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;
@@ -1228,12 +1232,12 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         binaries: import("../types/issues.js").IssueSeverity;
         unresolved: import("../types/issues.js").IssueSeverity;
         exports: import("../types/issues.js").IssueSeverity;
-        types: import("../types/issues.js").IssueSeverity;
         nsExports: import("../types/issues.js").IssueSeverity;
+        types: import("../types/issues.js").IssueSeverity;
         nsTypes: import("../types/issues.js").IssueSeverity;
-        duplicates: import("../types/issues.js").IssueSeverity;
         enumMembers: import("../types/issues.js").IssueSeverity;
         classMembers: import("../types/issues.js").IssueSeverity;
+        duplicates: import("../types/issues.js").IssueSeverity;
         _files: import("../types/issues.js").IssueSeverity;
     };
     tags: import("../types/options.js").Tags;

package/dist/util/create-options.js

@@ -94,7 +94,7 @@ export const createOptions = async (options) => {
             includedIssueTypes.binaries,
         isReportTypes: includedIssueTypes.types || includedIssueTypes.nsTypes || includedIssueTypes.enumMembers,
         isReportValues: includedIssueTypes.exports || includedIssueTypes.nsExports || isReportClassMembers,
-        isShowProgress: parsedCLIArgs['no-progress'] === false && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function',
+        isShowProgress: parsedCLIArgs['no-progress'] !== true && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function',
         isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
         isStrict,
         isTrace: Boolean(parsedCLIArgs.trace ?? parsedCLIArgs['trace-file'] ?? parsedCLIArgs['trace-export']),

package/dist/util/fs.d.ts

@@ -3,7 +3,8 @@ export declare const isFile: (filePath: string) => boolean;
 export declare const findFile: (workingDir: string, fileName: string) => string | undefined;
 export declare const loadFile: (filePath: string) => Promise<string>;
 export declare const loadJSON: (filePath: string) => Promise<any>;
+export declare const loadJSONC: (filePath: string) => Promise<any>;
 export declare const loadYAML: (filePath: string) => Promise<unknown>;
 export declare const loadTOML: (filePath: string) => Promise<import("smol-toml").TomlTable>;
-export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
+export declare const parseJSONC: (filePath: string, contents: string) => Promise<any>;
 export declare const parseYAML: (contents: string) => unknown;

package/dist/util/fs.js

@@ -4,7 +4,7 @@ import yaml from 'js-yaml';
 import { parse as parseTOML } from 'smol-toml';
 import stripJsonComments from 'strip-json-comments';
 import { LoaderError } from './errors.js';
-import { join } from './path.js';
+import { extname, join } from './path.js';
 export const isDirectory = (filePath) => {
     try {
         return statSync(filePath).isDirectory();
@@ -36,7 +36,16 @@ export const loadFile = async (filePath) => {
 };
 export const loadJSON = async (filePath) => {
     const contents = await loadFile(filePath);
-    return parseJSON(filePath, contents);
+    try {
+        return JSON.parse(contents);
+    }
+    catch {
+        return parseJSONC(filePath, contents);
+    }
+};
+export const loadJSONC = async (filePath) => {
+    const contents = await loadFile(filePath);
+    return parseJSONC(filePath, contents);
 };
 export const loadYAML = async (filePath) => {
     const contents = await loadFile(filePath);
@@ -46,12 +55,13 @@ export const loadTOML = async (filePath) => {
     const contents = await loadFile(filePath);
     return parseTOML(contents);
 };
-export const parseJSON = async (filePath, contents) => {
+export const parseJSONC = async (filePath, contents) => {
     try {
         return JSON.parse(stripJsonComments(contents, { trailingCommas: true, whitespace: false }));
     }
     catch (error) {
-        throw new LoaderError(`Error parsing ${filePath}`, { cause: error });
+        const message = `Error parsing ${filePath} ${extname(filePath) === '.json5' ? 'JSON5 features beyond comments and trailing commas are not fully supported. Consider converting to .jsonc format.' : ''}`;
+        throw new LoaderError(message, { cause: error });
     }
 };
 export const parseYAML = (contents) => {

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

@@ -31,8 +31,5 @@ export const getIncludedIssueTypes = (options) => {
             ? _include
             : [..._include, ...defaultIssueTypes]
         : defaultIssueTypes).filter(group => !_exclude.includes(group));
-    return ISSUE_TYPES.filter(i => i !== '_files').reduce((types, group) => {
-        types[group] = included.includes(group);
-        return types;
-    }, {});
+    return Object.fromEntries(ISSUE_TYPES.map(group => [group, included.includes(group)]));
 };

package/dist/util/get-referenced-inputs.d.ts

@@ -1,5 +1,5 @@
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
-import type { IssueCollector } from '../IssueCollector.js';
+import type { Issue } from '../types/issues.js';
 import { type Input } from './input.js';
-export declare const getReferencedInputsHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean) => (input: Input, workspace: Workspace) => string | undefined;
+export declare const getReferencedInputsHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean, addIssue: (issue: Issue) => void) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/get-referenced-inputs.js

@@ -7,7 +7,7 @@ import { _resolveSync } from './resolve.js';
 const getWorkspaceFor = (input, chief, workspace) => (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) ||
     (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) ||
     workspace;
-export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnored) => (input, workspace) => {
+export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue) => (input, workspace) => {
     const { specifier, containingFilePath } = input;
     if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
         return;
@@ -17,7 +17,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
         const isHandled = deputy.maybeAddReferencedBinary(inputWorkspace, binaryName);
         if (isHandled || input.optional)
             return;
-        collector.addIssue({
+        addIssue({
             type: 'binaries',
             filePath: containingFilePath,
             workspace: workspace.name,
@@ -35,7 +35,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
             if (isWorkspace || isDependency(input)) {
                 if (!isHandled) {
                     if (!input.optional && ((deputy.isProduction && input.production) || !deputy.isProduction)) {
-                        collector.addIssue({
+                        addIssue({
                             type: 'unlisted',
                             filePath: containingFilePath,
                             workspace: inputWorkspace.name,
@@ -65,7 +65,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
     if (input.optional)
         return;
     if (!isInternal(filePath)) {
-        collector.addIssue({
+        addIssue({
             type: 'unlisted',
             filePath: containingFilePath,
             workspace: workspace.name,
@@ -75,7 +75,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
     }
     else if (!isGitIgnored(filePath)) {
         if (!isDeferResolveEntry(input) && !isConfig(input)) {
-            collector.addIssue({
+            addIssue({
                 type: 'unresolved',
                 filePath: containingFilePath,
                 workspace: workspace.name,

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +1,4 @@
 import type { ImportDetails, ModuleGraph } from '../types/module-graph.js';
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportDetails | undefined, id: string) => boolean;
 export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportDetails | undefined, id: string) => [boolean, string?];
-export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "types" | "nsExports" | "nsTypes";
+export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";