knip 5.68.0 → 5.69.1

package/dist/reporters/json.js

@@ -32,6 +32,7 @@ export default async ({ report, issues, options, cwd }) => {
             ...(report.enumMembers && { enumMembers: {} }),
             ...(report.classMembers && { classMembers: {} }),
             ...(report.duplicates && { duplicates: [] }),
+            ...(report.catalog && { catalog: [] }),
         };
         return row;
     };

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

@@ -3,7 +3,7 @@ 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) => "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 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" | "Unused catalog entries";
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;
 type LogIssueLine = {

package/dist/schema/configuration.d.ts

@@ -227,6 +227,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>]>>;
+    mdx: 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>]>>;
     mdxlint: 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>>]>>;
@@ -813,6 +818,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>]>>;
+        mdx: 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>]>>;
         mdxlint: 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>>]>>;
@@ -1184,10 +1194,10 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         ignoreUnresolved: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<RegExp, RegExp>]>>>;
         includeEntryExports: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>>>;
-    include: z.ZodMiniOptional<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">]>>>;
-    exclude: z.ZodMiniOptional<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">]>>>;
+    include: z.ZodMiniOptional<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">, z.ZodMiniLiteral<"catalog">]>>>;
+    exclude: z.ZodMiniOptional<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">, z.ZodMiniLiteral<"catalog">]>>>;
     $schema: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    rules: z.ZodMiniOptional<z.ZodMiniRecord<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">]> & z.core.$partial, z.ZodMiniEnum<{
+    rules: z.ZodMiniOptional<z.ZodMiniRecord<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">, z.ZodMiniLiteral<"catalog">]> & z.core.$partial, z.ZodMiniEnum<{
         error: "error";
         warn: "warn";
         off: "off";
@@ -1204,7 +1214,7 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     ignoreExportsUsedInFile: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
         [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">]>>>>;
+    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">, z.ZodMiniLiteral<"catalog">]>>>>;
     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>]>>>;

package/dist/schema/configuration.js

@@ -22,6 +22,7 @@ const issueTypeSchema = z.union([
     z.literal('duplicates'),
     z.literal('enumMembers'),
     z.literal('classMembers'),
+    z.literal('catalog'),
 ]);
 const rulesSchema = z.partialRecord(issueTypeSchema, z.enum(['error', 'warn', 'off']));
 const ignorableSymbolTypes = Object.values(SYMBOL_TYPE).filter(type => type !== 'unknown');

package/dist/schema/plugins.d.ts

@@ -231,6 +231,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>]>;
+    mdx: 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>]>;
     mdxlint: 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

@@ -55,6 +55,7 @@ export const pluginsSchema = z.object({
     'lockfile-lint': pluginSchema,
     'lost-pixel': pluginSchema,
     markdownlint: pluginSchema,
+    mdx: pluginSchema,
     mdxlint: pluginSchema,
     metro: pluginSchema,
     mocha: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | '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' | 'mdxlint' | '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", "astro-db", "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", "mdxlint", "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' | 'astro-db' | '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' | 'mdx' | 'mdxlint' | '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", "astro-db", "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", "mdx", "mdxlint", "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

@@ -44,6 +44,7 @@ export const pluginNames = [
     'lockfile-lint',
     'lost-pixel',
     'markdownlint',
+    'mdx',
     'mdxlint',
     'metro',
     'mocha',

package/dist/types/config.d.ts

@@ -3,6 +3,7 @@ import type { z } from 'zod/mini';
 import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
 import type { knipConfigurationSchema } from '../schema/configuration.js';
 import type { pluginSchema } from '../schema/plugins.js';
+import type { ParsedCLIArgs } from '../util/cli-arguments.js';
 import type { Input } from '../util/input.js';
 import type { Args } from './args.js';
 import type { IssueType, SymbolType } from './issues.js';
@@ -21,6 +22,7 @@ export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
 }
 export type BinaryResolver = (binary: string, args: string[], options: BinaryResolverOptions) => Input[];
 export type RawConfiguration = z.infer<typeof knipConfigurationSchema>;
+export type RawConfigurationOrFn = RawConfiguration | ((options: ParsedCLIArgs) => RawConfiguration | Promise<RawConfiguration>);
 export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
 export type IgnorePatterns = (string | RegExp)[];
 type IgnorableExport = Exclude<SymbolType, 'unknown'>;

package/dist/types/exports.d.ts

@@ -1,7 +1,7 @@
 import type ts from 'typescript';
 import type { SymbolType } from './issues.js';
 type Identifier = string;
-export type ExportPosTuple = [number, number, number];
+type ExportPosTuple = [number, number, number];
 export type Fix = ExportPosTuple | undefined;
 export type Fixes = Array<ExportPosTuple>;
 export type ExportNode = {

package/dist/types/imports.d.ts

@@ -6,7 +6,5 @@ export interface ImportNode {
     namespace?: string | undefined;
     pos: number;
     symbol?: ts.Symbol;
-    isTypeOnly?: boolean;
-    isReExport?: boolean;
-    resolve?: boolean;
+    modifiers: number;
 }

package/dist/types/issues.d.ts

@@ -1,4 +1,5 @@
 import type { SYMBOL_TYPE } from '../constants.js';
+import type { Fixes } from './exports.js';
 export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
 export type IssueSymbol = {
     symbol: string;
@@ -19,6 +20,7 @@ export type Issue = {
     pos?: number;
     line?: number;
     col?: number;
+    fixes: Fixes;
     isFixed?: boolean;
 };
 export type IssueSet = Set<string>;
@@ -39,6 +41,7 @@ export type Issues = {
     duplicates: IssueRecords;
     enumMembers: IssueRecords;
     classMembers: IssueRecords;
+    catalog: IssueRecords;
 };
 export type IssueType = keyof Issues;
 export type SymbolIssueType = Exclude<IssueType, 'files'>;

package/dist/types/package-json.d.ts

@@ -1,4 +1,4 @@
-import type { PluginMap } from './config.js';
+import type { PluginMap, WorkspaceConfiguration } from './config.js';
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 type Dependencies = Record<string, string>;
@@ -23,6 +23,8 @@ type PluginConfig<P> = {
 };
 type Plugins = PluginConfig<PluginMap>;
 export type Scripts = Record<string, string>;
+export type Catalog = Record<string, string>;
+export type Catalogs = Record<string, Catalog>;
 export type PackageJson = {
     name?: string;
     main?: string;
@@ -30,6 +32,8 @@ export type PackageJson = {
     version?: string;
     workspaces?: string[] | {
         packages?: string[];
+        catalog?: Catalog;
+        catalogs?: Catalogs;
     };
     exports?: Exports;
     imports?: Imports;
@@ -41,11 +45,18 @@ export type PackageJson = {
     peerDependenciesMeta?: Record<string, {
         optional: true;
     }>;
+    resolutions?: Dependencies;
     module?: string;
     browser?: string;
     types?: string;
     typings?: string;
+    catalog?: Catalog;
+    catalogs?: Catalogs;
     packageManager?: string;
+    pnpm?: {
+        overrides?: Dependencies;
+    };
+    knip?: WorkspaceConfiguration;
 } & Plugins;
 export type WorkspacePackage = {
     dir: string;

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-export type { RawConfiguration as KnipConfig } from './types/config.js';
+export type { RawConfigurationOrFn as KnipConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import type { Fix } from '../types/exports.js';
 import type { SymbolType } from '../types/issues.js';
-export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): boolean;
+export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): node is ts.ImportDeclaration;
 export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpression;
 export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
 export declare function isRequireCall(callExpression: ts.Node): callExpression is ts.CallExpression;

package/dist/typescript/get-imports-and-exports.js

@@ -1,10 +1,10 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
-import { ALIAS_TAG, ANONYMOUS, IMPORT_STAR, PROTOCOL_VIRTUAL } from '../constants.js';
+import { ALIAS_TAG, ANONYMOUS, IMPORT_MODIFIERS, IMPORT_STAR, PROTOCOL_VIRTUAL } from '../constants.js';
 import { addNsValue, addValue, createImports } from '../util/module-graph.js';
 import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
-import { isInNodeModules } from '../util/path.js';
+import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { getAccessMembers, getDestructuredNames, getJSDocTags, getLineAndCharacterOfPosition, getTypeRef, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isInForIteration, isObjectEnumerationCallExpressionArgument, isReferencedInExport, } from './ast-helpers.js';
 import { findInternalReferences, isType } from './find-internal-references.js';
@@ -76,7 +76,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         }
     };
     const addInternalImport = (options) => {
-        const { identifier, symbol, filePath, namespace, alias, specifier, isReExport } = options;
+        const { identifier, symbol, filePath, namespace, alias, specifier } = options;
         const isStar = identifier === IMPORT_STAR;
         specifiers.add([{ specifier, pos: options.pos, line: options.line, col: options.col }, filePath]);
         const file = internal.get(filePath);
@@ -84,7 +84,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         if (!file)
             internal.set(filePath, imports);
         const nsOrAlias = symbol ? String(symbol.escapedName) : alias;
-        if (isReExport) {
+        if (options.modifiers & IMPORT_MODIFIERS.RE_EXPORT) {
             if (isStar && namespace) {
                 addValue(imports.reExportedNs, namespace, sourceFile.fileName);
             }
@@ -118,7 +118,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         if (module) {
             const filePath = module.resolvedFileName;
             if (filePath) {
-                if (opts.resolve && !isInNodeModules(filePath)) {
+                if (opts.modifiers && opts.modifiers & IMPORT_MODIFIERS.ENTRY && !isInNodeModules(filePath)) {
                     resolved.add(filePath);
                     return;
                 }
@@ -128,36 +128,37 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                         ...opts,
                         identifier: opts.identifier ?? ANONYMOUS,
                         filePath,
-                        isReExport: opts.isReExport ?? false,
                         line: line + 1,
                         col: character + 1,
                     });
                 }
                 if (module.isExternalLibraryImport) {
-                    if (options.skipTypeOnly && opts.isTypeOnly)
+                    if (options.skipTypeOnly && opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY)
                         return;
-                    const isInNM = isInNodeModules(opts.specifier);
-                    const sanitizedSpecifier = sanitizeSpecifier(isInNM || isInNodeModules(filePath) ? getPackageNameFromFilePath(opts.specifier) : opts.specifier);
+                    const sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(filePath) || isInNodeModules(opts.specifier)
+                        ? getPackageNameFromFilePath(opts.specifier)
+                        : opts.specifier);
                     if (!isStartsLikePackageName(sanitizedSpecifier)) {
                         return;
                     }
-                    if (isInNM) {
-                        external.add({ specifier: sanitizedSpecifier });
-                    }
-                    else {
-                        const { line, character } = sourceFile.getLineAndCharacterOfPosition(opts.pos);
-                        external.add({ specifier: sanitizedSpecifier, pos: opts.pos, line: line + 1, col: character + 2 });
-                    }
+                    const pos = node.moduleSpecifier?.getStart() ?? opts.pos;
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+                    external.add({ specifier: sanitizedSpecifier, pos: opts.pos, line: line + 1, col: character + 2 });
                 }
             }
         }
         else {
-            if (options.skipTypeOnly && opts.isTypeOnly)
+            if (options.skipTypeOnly && opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY)
                 return;
             if (shouldIgnore(getJSDocTags(node), options.tags))
                 return;
             if (opts.specifier.startsWith(PROTOCOL_VIRTUAL))
                 return;
+            const r = resolve(dirname(sourceFile.fileName), opts.specifier);
+            if (opts.modifiers && opts.modifiers & IMPORT_MODIFIERS.OPTIONAL) {
+                resolved.add(r);
+                return;
+            }
             const pos = 'moduleSpecifier' in node ? node.moduleSpecifier.pos : node.pos;
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
             unresolved.add({ specifier: opts.specifier, pos, line: line + 1, col: character + 2 });

package/dist/typescript/visitors/dynamic-imports/importCall.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ANONYMOUS } from '../../../constants.js';
+import { ANONYMOUS, IMPORT_MODIFIERS } from '../../../constants.js';
 import { findAncestor, findDescendants, getAccessedIdentifiers, isAccessExpression, isImportCall, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
@@ -7,6 +7,7 @@ export default visit(() => true, node => {
     if (isImportCall(node)) {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
+            const modifiers = IMPORT_MODIFIERS.NONE;
             if (specifier) {
                 const accessExpression = findAncestor(node, _node => {
                     if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
@@ -27,7 +28,7 @@ export default visit(() => true, node => {
                                     if (accessExpressions.length > 0) {
                                         return accessExpressions.map(binding => {
                                             const identifier = String(binding.name.escapedText);
-                                            return { identifier, specifier, pos };
+                                            return { identifier, specifier, pos, modifiers };
                                         });
                                     }
                                 }
@@ -35,21 +36,21 @@ export default visit(() => true, node => {
                                     return arg.name.elements.map(element => {
                                         const identifier = (element.propertyName ?? element.name).getText();
                                         const alias = element.propertyName ? element.name.getText() : undefined;
-                                        return { identifier, alias, specifier, pos: element.pos };
+                                        return { identifier, alias, specifier, pos: element.pos, modifiers };
                                     });
                                 }
                             }
-                            return { identifier: 'default', specifier, pos };
+                            return { identifier: 'default', specifier, pos, modifiers };
                         }
                         if (identifier !== 'catch')
-                            return { identifier, specifier, pos };
+                            return { identifier, specifier, pos, modifiers };
                     }
                     if (ts.isElementAccessExpression(accessExpression) &&
                         ts.isStringLiteral(accessExpression.argumentExpression)) {
                         const name = stripQuotes(accessExpression.argumentExpression.text);
                         const pos = accessExpression.argumentExpression.pos;
                         const identifier = name;
-                        return { identifier, specifier, pos };
+                        return { identifier, specifier, pos, modifiers };
                     }
                 }
                 const variableDeclaration = accessExpression &&
@@ -67,9 +68,16 @@ export default visit(() => true, node => {
                         const scope = findAncestor(variableDeclaration, ts.isFunctionBody) || node.getSourceFile();
                         const accessed = getAccessedIdentifiers(alias, scope);
                         if (accessed.length > 0) {
-                            return accessed.map(acc => ({ identifier: acc.identifier, alias, symbol, specifier, pos: acc.pos }));
+                            return accessed.map(acc => ({
+                                identifier: acc.identifier,
+                                alias,
+                                symbol,
+                                specifier,
+                                pos: acc.pos,
+                                modifiers,
+                            }));
                         }
-                        return { identifier: 'default', alias, symbol, specifier, pos: node.arguments[0].pos };
+                        return { identifier: 'default', alias, symbol, specifier, pos: node.arguments[0].pos, modifiers };
                     }
                     const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
                     if (bindings.length > 0) {
@@ -77,10 +85,10 @@ export default visit(() => true, node => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
                             const symbol = getSymbol(element, isTLA);
-                            return { identifier, alias, symbol, specifier, pos: element.pos };
+                            return { identifier, alias, symbol, specifier, pos: element.pos, modifiers };
                         });
                     }
-                    return { identifier: ANONYMOUS, specifier, pos: node.arguments[0].pos };
+                    return { identifier: ANONYMOUS, specifier, pos: node.arguments[0].pos, modifiers };
                 }
                 const arrayLiteralExpression = node.parent;
                 const variableDeclarationParent = node.parent.parent?.parent?.parent;
@@ -98,20 +106,20 @@ export default visit(() => true, node => {
                                 const identifier = (element.propertyName ?? element.name).getText();
                                 const alias = element.propertyName ? element.name.getText() : undefined;
                                 const symbol = getSymbol(element, isTL);
-                                return { identifier, alias, symbol, specifier, pos: element.pos };
+                                return { identifier, alias, symbol, specifier, pos: element.pos, modifiers };
                             });
                         }
                         if (!ts.isOmittedExpression(element) && ts.isIdentifier(element.name)) {
                             const alias = String(element.name.escapedText);
                             const symbol = getSymbol(element, isTL);
-                            return { identifier: 'default', symbol, alias, specifier, pos: element.pos };
+                            return { identifier: 'default', symbol, alias, specifier, pos: element.pos, modifiers };
                         }
-                        return { identifier: 'default', specifier, pos: element.pos };
+                        return { identifier: 'default', specifier, pos: element.pos, modifiers };
                     }
                 }
-                return { identifier: 'default', specifier, pos: node.arguments[0].pos };
+                return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
             }
-            return { specifier, identifier: 'default', pos: node.arguments[0].pos };
+            return { specifier, identifier: 'default', pos: node.arguments[0].pos, modifiers };
         }
     }
 });

package/dist/typescript/visitors/dynamic-imports/importType.js

@@ -1,9 +1,15 @@
 import ts from 'typescript';
+import { IMPORT_MODIFIERS } from '../../../constants.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (ts.isImportTypeNode(node)) {
         if (ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal)) {
-            return { specifier: node.argument.literal.text, identifier: undefined, pos: 0, isTypeOnly: true };
+            return {
+                specifier: node.argument.literal.text,
+                identifier: undefined,
+                pos: node.argument.literal.getStart(),
+                modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+            };
         }
     }
 });

package/dist/typescript/visitors/dynamic-imports/index.js

@@ -3,5 +3,6 @@ import importType from './importType.js';
 import jsDocType from './jsDocType.js';
 import requireCall from './requireCall.js';
 import resolveCall from './resolveCall.js';
-const visitors = [importCall, importType, jsDocType, resolveCall, requireCall];
+import urlConstructor from './urlConstructor.js';
+const visitors = [importCall, importType, jsDocType, resolveCall, requireCall, urlConstructor];
 export default (sourceFile) => visitors.map(v => v(sourceFile));

package/dist/typescript/visitors/dynamic-imports/jsDocType.js

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { IMPORT_MODIFIERS } from '../../../constants.js';
 import { importVisitor as visit } from '../index.js';
 const supportsJSDocImportTag = 'isJSDocImportTag' in ts;
 const getImportSpecifiers = (node) => {
@@ -8,12 +9,22 @@ const getImportSpecifiers = (node) => {
             const importClause = node.argument;
             if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
                 const identifier = node.qualifier && ts.isIdentifier(node.qualifier) ? String(node.qualifier.escapedText) : 'default';
-                imports.push({ specifier: importClause.literal.text, identifier, pos: importClause.literal.pos });
+                imports.push({
+                    specifier: importClause.literal.text,
+                    identifier,
+                    pos: importClause.literal.pos,
+                    modifiers: IMPORT_MODIFIERS.NONE,
+                });
             }
         }
         if (supportsJSDocImportTag && ts.isJSDocImportTag(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
             const moduleSpecifier = node.moduleSpecifier;
-            imports.push({ specifier: moduleSpecifier.text, identifier: undefined, pos: moduleSpecifier.pos });
+            imports.push({
+                specifier: moduleSpecifier.text,
+                identifier: undefined,
+                pos: moduleSpecifier.pos,
+                modifiers: IMPORT_MODIFIERS.NONE,
+            });
         }
         ts.forEachChild(node, visit);
     }

package/dist/typescript/visitors/dynamic-imports/requireCall.js

@@ -1,22 +1,21 @@
 import ts from 'typescript';
-import { IMPORT_STAR } from '../../../constants.js';
+import { IMPORT_MODIFIERS, IMPORT_STAR } from '../../../constants.js';
 import { findAncestor, findDescendants, isModuleExportsAccess, isRequireCall, isTopLevel } from '../../ast-helpers.js';
-import { isNotJS } from '../helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (isRequireCall(node)) {
         if (ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
+            const modifiers = IMPORT_MODIFIERS.NONE;
             if (specifier) {
                 const propertyAccessExpression = findAncestor(node, _node => {
                     if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
                         return 'STOP';
                     return ts.isPropertyAccessExpression(_node);
                 });
-                const resolve = isNotJS(node.getSourceFile());
                 if (propertyAccessExpression) {
                     const identifier = String(propertyAccessExpression.name.escapedText);
-                    return { identifier, specifier, pos: propertyAccessExpression.name.pos, resolve };
+                    return { identifier, specifier, pos: propertyAccessExpression.name.pos, modifiers };
                 }
                 const variableDeclaration = node.parent;
                 if (ts.isVariableDeclaration(variableDeclaration) &&
@@ -30,7 +29,7 @@ export default visit(() => true, node => {
                             symbol: isTLA ? variableDeclaration.symbol : undefined,
                             specifier,
                             pos: node.arguments[0].pos,
-                            resolve,
+                            modifiers,
                         };
                     }
                     const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
@@ -39,17 +38,22 @@ export default visit(() => true, node => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
                             const symbol = isTLA ? element.symbol : undefined;
-                            return { identifier, specifier, alias, symbol, pos: element.pos, resolve };
+                            return { identifier, specifier, alias, symbol, pos: element.pos, modifiers };
                         });
                     }
-                    return { identifier: 'default', specifier, pos: node.arguments[0].pos, resolve };
+                    return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
                 }
                 if (ts.isBinaryExpression(node.parent) &&
                     ts.isPropertyAccessExpression(node.parent.left) &&
                     isModuleExportsAccess(node.parent.left)) {
-                    return { identifier: IMPORT_STAR, specifier, isReExport: true, pos: node.arguments[0].pos };
+                    return {
+                        identifier: IMPORT_STAR,
+                        specifier,
+                        pos: node.arguments[0].pos,
+                        modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                    };
                 }
-                return { identifier: 'default', specifier, pos: node.arguments[0].pos, resolve };
+                return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
             }
         }
     }

package/dist/typescript/visitors/dynamic-imports/resolveCall.js

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { IMPORT_MODIFIERS } from '../../../constants.js';
 import { isPropertyAccessCall } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
@@ -6,7 +7,12 @@ export default visit(() => true, node => {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
             if (specifier)
-                return { specifier, identifier: undefined, pos: node.arguments[0].pos, resolve: true };
+                return {
+                    specifier,
+                    identifier: undefined,
+                    pos: node.arguments[0].pos,
+                    modifiers: IMPORT_MODIFIERS.ENTRY,
+                };
         }
     }
 });

package/dist/typescript/visitors/dynamic-imports/urlConstructor.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+export default _default;