knip 5.80.2 → 5.82.0

package/dist/ConfigurationChief.d.ts

@@ -3,6 +3,7 @@ import type { ConfigurationHint } from './types/issues.js';
 import type { WorkspacePackage } from './types/package-json.js';
 import type { MainOptions } from './util/create-options.js';
 import { type WorkspaceGraph } from './util/create-workspace-graph.js';
+import { type WorkspaceFilePathFilter } from './util/workspace-file-filter.js';
 export declare const isDefaultPattern: (type: "entry" | "project", id: string) => boolean;
 export type Workspace = {
     name: string;
@@ -23,18 +24,19 @@ export declare class ConfigurationChief {
     isStrict: boolean;
     isIncludeEntryExports: boolean;
     config: Configuration;
-    workspace: string | undefined;
+    workspace: string | string[] | undefined;
+    selectedWorkspaces: Set<string> | undefined;
+    workspaceFilePathFilter: WorkspaceFilePathFilter;
     workspaces: string[];
     ignoredWorkspacePatterns: string[];
     workspacePackages: Map<string, WorkspacePackage>;
     workspacesByPkgName: Map<string, Workspace>;
-    workspacesByName: Map<string, Workspace>;
+    workspacesByDir: Map<string, Workspace>;
     additionalWorkspaceNames: Set<string>;
     availableWorkspaceNames: string[];
     availableWorkspacePkgNames: Set<string>;
     availableWorkspaceDirs: string[];
     workspaceGraph: WorkspaceGraph;
-    includedWorkspaces: Workspace[];
     constructor(options: MainOptions);
     getConfigurationHints(): ConfigurationHint[];
     private normalize;
@@ -52,6 +54,7 @@ export declare class ConfigurationChief {
     createIgnoredWorkspaceMatcher(name: string, dir: string): (filePath: string) => boolean;
     getNegatedWorkspacePatterns(name: string): string[];
     private getConfigKeyForWorkspace;
+    private getSelectedWorkspaces;
     getWorkspaceConfig(workspaceName: string): {
         angular?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -348,6 +351,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        nitro?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -548,6 +556,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        sveltekit?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         svgo?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -773,6 +786,7 @@ export declare class ConfigurationChief {
         next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "next-intl"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "next-mdx"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nitro?: (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;
@@ -811,6 +825,7 @@ export declare class ConfigurationChief {
         stryker?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sveltekit?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svgo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svgr?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         swc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -4,7 +4,6 @@ import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { pluginNames } from './types/PluginNames.js';
 import { arrayify, compact, partition } from './util/array.js';
 import { createWorkspaceGraph } from './util/create-workspace-graph.js';
-import { ConfigurationError } from './util/errors.js';
 import { isDirectory, isFile } from './util/fs.js';
 import { _dirGlob, removeProductionSuffix } from './util/glob.js';
 import { graphSequencer } from './util/graph-sequencer.js';
@@ -14,6 +13,8 @@ import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
 import { byPathDepth } from './util/workspace.js';
+import { createWorkspaceFilePathFilter } from './util/workspace-file-filter.js';
+import { selectWorkspaces } from './util/workspace-selectors.js';
 const defaultBaseFilenamePattern = '{index,cli,main}';
 export const isDefaultPattern = (type, id) => {
     if (type === 'project')
@@ -31,9 +32,10 @@ const getDefaultWorkspaceConfig = (extensions = []) => {
 const isPluginName = (name) => pluginNames.includes(name);
 const defaultConfig = {
     ignore: [],
-    ignoreFiles: [],
     ignoreBinaries: [],
     ignoreDependencies: [],
+    ignoreFiles: [],
+    ignoreIssues: {},
     ignoreMembers: [],
     ignoreUnresolved: [],
     ignoreWorkspaces: [],
@@ -51,17 +53,18 @@ export class ConfigurationChief {
     isIncludeEntryExports;
     config;
     workspace;
+    selectedWorkspaces;
+    workspaceFilePathFilter = () => true;
     workspaces;
     ignoredWorkspacePatterns = [];
     workspacePackages = new Map();
     workspacesByPkgName = new Map();
-    workspacesByName = new Map();
+    workspacesByDir = new Map();
     additionalWorkspaceNames = new Set();
     availableWorkspaceNames = [];
     availableWorkspacePkgNames = new Set();
     availableWorkspaceDirs = [];
     workspaceGraph = new Map();
-    includedWorkspaces = [];
     constructor(options) {
         this.cwd = options.cwd;
         this.isProduction = options.isProduction;
@@ -98,7 +101,7 @@ export class ConfigurationChief {
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
         const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
-        const ignoreIssues = rawConfig.ignoreIssues;
+        const ignoreIssues = rawConfig.ignoreIssues ?? {};
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
         const { syncCompilers, asyncCompilers } = rawConfig;
@@ -137,14 +140,16 @@ export class ConfigurationChief {
             .reverse()
             .map(dir => join(this.cwd, dir));
         this.workspaceGraph = createWorkspaceGraph(this.cwd, this.availableWorkspaceNames, wsPkgNames, packages);
-        this.includedWorkspaces = this.getIncludedWorkspaces();
-        for (const workspace of this.includedWorkspaces) {
+        this.selectedWorkspaces = this.getSelectedWorkspaces();
+        this.workspaceFilePathFilter = createWorkspaceFilePathFilter(this.cwd, this.selectedWorkspaces, this.availableWorkspaceNames);
+        const includedWorkspaces = this.getIncludedWorkspaces();
+        for (const workspace of includedWorkspaces) {
             this.workspacesByPkgName.set(workspace.pkgName, workspace);
-            this.workspacesByName.set(workspace.name, workspace);
+            this.workspacesByDir.set(workspace.dir, workspace);
         }
-        const sorted = graphSequencer(this.workspaceGraph, this.includedWorkspaces.map(workspace => workspace.dir));
+        const sorted = graphSequencer(this.workspaceGraph, Array.from(this.workspacesByDir.keys()).filter(dir => this.workspaceGraph.has(dir)));
         const [root, rest] = partition(sorted.chunks.flat(), dir => dir === this.cwd);
-        return [...root, ...rest.reverse()].map(dir => this.includedWorkspaces.find(w => w.dir === dir));
+        return [...root, ...rest.reverse()].map(dir => this.workspacesByDir.get(dir));
     }
     getListedWorkspaces() {
         return this.workspaces.map(pattern => pattern.replace(/(?<=!?)\.\//, ''));
@@ -180,53 +185,48 @@ export class ConfigurationChief {
     getAvailableWorkspaceNames(names) {
         const availableWorkspaceNames = [];
         const [ignore, patterns] = partition(this.ignoredWorkspacePatterns, pattern => pattern.startsWith('!'));
+        const ignoreSliced = ignore.map(pattern => pattern.slice(1));
         for (const name of names) {
-            if (!picomatch.isMatch(name, patterns, { ignore: ignore.map(pattern => pattern.slice(1)) })) {
+            if (!picomatch.isMatch(name, patterns, { ignore: ignoreSliced })) {
                 availableWorkspaceNames.push(name);
             }
         }
         return availableWorkspaceNames;
     }
     getIncludedWorkspaces() {
-        if (this.workspace) {
-            const dir = path.resolve(this.cwd, this.workspace);
-            if (!isDirectory(dir))
-                throw new ConfigurationError('Workspace is not a directory');
-            if (!isFile(dir, 'package.json'))
-                throw new ConfigurationError('Unable to find package.json in workspace');
-        }
-        const getAncestors = (name) => (ancestors, ancestorName) => {
-            if (name === ancestorName)
-                return ancestors;
-            if (ancestorName === ROOT_WORKSPACE_NAME || name.startsWith(`${ancestorName}/`))
-                ancestors.push(ancestorName);
-            return ancestors;
-        };
-        const workspaceNames = this.workspace
-            ? [...this.availableWorkspaceNames.reduce(getAncestors(this.workspace), []), this.workspace]
+        const selectedWorkspaces = this.selectedWorkspaces;
+        const isAncestor = (name, ancestor) => ancestor !== name && (ancestor === ROOT_WORKSPACE_NAME || name.startsWith(`${ancestor}/`));
+        const getAncestors = (name) => this.availableWorkspaceNames.filter(a => isAncestor(name, a));
+        const workspaceNames = selectedWorkspaces
+            ? Array.from(selectedWorkspaces).flatMap(name => [...getAncestors(name), name])
             : this.availableWorkspaceNames;
         const ws = new Set();
-        if (this.workspace && this.isStrict) {
-            ws.add(this.workspace);
+        if (selectedWorkspaces && this.isStrict) {
+            for (const name of selectedWorkspaces)
+                ws.add(name);
         }
-        else if (this.workspace) {
+        else if (selectedWorkspaces) {
             const graph = this.workspaceGraph;
             if (graph) {
                 const seen = new Set();
-                const initialWorkspaces = workspaceNames.map(name => join(this.cwd, name));
+                const initialWorkspaces = new Set(workspaceNames.map(name => join(this.cwd, name)));
                 const workspaceDirsWithDependents = new Set(initialWorkspaces);
                 const addDependents = (dir) => {
                     seen.add(dir);
                     const dirs = graph.get(dir);
                     if (!dirs || dirs.size === 0)
                         return;
-                    if (initialWorkspaces.some(dir => dirs.has(dir)))
-                        workspaceDirsWithDependents.add(dir);
+                    for (const d of dirs)
+                        if (initialWorkspaces.has(d)) {
+                            workspaceDirsWithDependents.add(dir);
+                            break;
+                        }
                     for (const dir of dirs)
                         if (!seen.has(dir))
                             addDependents(dir);
                 };
-                this.availableWorkspaceDirs.forEach(addDependents);
+                for (const dir of this.availableWorkspaceDirs)
+                    addDependents(dir);
                 for (const dir of workspaceDirsWithDependents)
                     ws.add(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME);
             }
@@ -250,7 +250,7 @@ export class ConfigurationChief {
                 pkgName,
                 dir,
                 config: this.getConfigForWorkspace(name),
-                ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
+                ancestors: getAncestors(name),
                 manifestPath,
                 manifestStr,
                 ignoreMembers,
@@ -261,9 +261,8 @@ export class ConfigurationChief {
         return this.workspacePackages.get(name)?.manifest;
     }
     getDescendentWorkspaces(name) {
-        return this.availableWorkspaceNames
-            .filter(workspaceName => workspaceName !== name)
-            .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(`${name}/`));
+        const prefix = `${name}/`;
+        return this.availableWorkspaceNames.filter(workspaceName => workspaceName !== name && (name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(prefix)));
     }
     getIgnoredWorkspacesFor(name) {
         return this.ignoredWorkspacePatterns
@@ -294,6 +293,12 @@ export class ConfigurationChief {
             .reverse()
             .find(pattern => picomatch.isMatch(workspaceName, pattern));
     }
+    getSelectedWorkspaces() {
+        if (!this.workspace)
+            return;
+        const workspaceSelectors = Array.isArray(this.workspace) ? this.workspace : [this.workspace];
+        return selectWorkspaces(workspaceSelectors, this.cwd, this.workspacePackages, this.availableWorkspaceNames);
+    }
     getWorkspaceConfig(workspaceName) {
         const key = this.getConfigKeyForWorkspace(workspaceName);
         const workspaces = this.rawConfig?.workspaces ?? {};
@@ -341,13 +346,23 @@ export class ConfigurationChief {
     }
     findWorkspaceByFilePath(filePath) {
         const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(`${workspaceDir}/`));
-        return this.includedWorkspaces.find(workspace => workspace.dir === workspaceDir);
+        if (!workspaceDir)
+            return undefined;
+        return this.workspacesByDir.get(workspaceDir);
     }
     getUnusedIgnoredWorkspaces() {
         const ignoredWorkspaceNames = this.config.ignoreWorkspaces.map(removeProductionSuffix);
-        const workspaceNames = [...this.workspacePackages.keys(), ...this.additionalWorkspaceNames];
+        const matchesWorkspace = (pattern) => {
+            for (const name of this.workspacePackages.keys())
+                if (picomatch.isMatch(name, pattern))
+                    return true;
+            for (const name of this.additionalWorkspaceNames)
+                if (picomatch.isMatch(name, pattern))
+                    return true;
+            return false;
+        };
         return ignoredWorkspaceNames
-            .filter(ignoredWorkspaceName => !workspaceNames.some(name => picomatch.isMatch(name, ignoredWorkspaceName)))
+            .filter(ignoredWorkspaceName => !matchesWorkspace(ignoredWorkspaceName))
             .filter(ignoredWorkspaceName => {
             const dir = join(this.cwd, ignoredWorkspaceName);
             return !isDirectory(dir) || isFile(dir, 'package.json');

package/dist/DependencyDeputy.d.ts

@@ -32,7 +32,8 @@ export declare class DependencyDeputy {
         dependencies: DependencyArray;
         devDependencies: DependencyArray;
         peerDependencies: DependencySet;
-        optionalPeerDependencies: DependencyArray;
+        optionalPeerDependencies: DependencySet;
+        requiredPeerDependencies: DependencyArray;
         allDependencies: DependencySet;
         ignoreDependencies: (string | RegExp)[];
         ignoreBinaries: (string | RegExp)[];
@@ -55,7 +56,7 @@ export declare class DependencyDeputy {
         name: string;
         isPeerOptional: boolean;
     }[];
-    getOptionalPeerDependencies(workspaceName: string): DependencyArray;
+    getOptionalPeerDependencies(workspaceName: string): DependencySet;
     maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
@@ -74,4 +75,5 @@ export declare class DependencyDeputy {
     getConfigurationHints(): ConfigurationHint[];
     addIgnoredDependencies(workspaceName: string, identifier: string): void;
     addIgnoredBinaries(workspaceName: string, identifier: string): void;
+    addIgnoredUnresolved(workspaceName: string, identifier: string): void;
 }

package/dist/DependencyDeputy.js

@@ -29,11 +29,14 @@ export class DependencyDeputy {
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
         const optionalDependencies = Object.keys(manifest.optionalDependencies ?? {});
-        const optionalPeerDependencies = manifest.peerDependenciesMeta
-            ? peerDependencies.filter(peerDependency => manifest.peerDependenciesMeta &&
-                peerDependency in manifest.peerDependenciesMeta &&
-                manifest.peerDependenciesMeta[peerDependency].optional)
-            : [];
+        const optionalPeerDependencies = new Set();
+        if (manifest.peerDependenciesMeta) {
+            for (const dep of peerDependencies) {
+                if (manifest.peerDependenciesMeta[dep]?.optional)
+                    optionalPeerDependencies.add(dep);
+            }
+        }
+        const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
         const packageNames = [
@@ -68,6 +71,7 @@ export class DependencyDeputy {
             devDependencies,
             peerDependencies: new Set(peerDependencies),
             optionalPeerDependencies,
+            requiredPeerDependencies,
             allDependencies: new Set(allDependencies),
         });
     }
@@ -79,7 +83,7 @@ export class DependencyDeputy {
         if (!manifest)
             return [];
         if (this.isStrict)
-            return [...manifest.dependencies, ...manifest.peerDependencies];
+            return [...manifest.dependencies, ...manifest.requiredPeerDependencies];
         return manifest.dependencies;
     }
     getDevDependencies(workspaceName) {
@@ -122,10 +126,7 @@ export class DependencyDeputy {
         return this.hostDependencies.get(workspaceName)?.get(dependency) ?? [];
     }
     getOptionalPeerDependencies(workspaceName) {
-        const manifest = this._manifests.get(workspaceName);
-        if (!manifest)
-            return [];
-        return manifest.optionalPeerDependencies;
+        return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
     maybeAddReferencedExternalDependency(workspace, packageName) {
         if (!this.isReportDependencies)
@@ -227,7 +228,9 @@ export class DependencyDeputy {
                 const position = peeker.getLocation('devDependencies', symbol);
                 devDependencyIssues.push({ type: 'devDependencies', filePath, workspace, symbol, fixes: [], ...position });
             }
-            for (const symbol of this.getOptionalPeerDependencies(workspace).filter(d => isReferencedDependency(d))) {
+            for (const symbol of this.getOptionalPeerDependencies(workspace)) {
+                if (!isReferencedDependency(symbol))
+                    continue;
                 const pos = peeker.getLocation('optionalPeerDependencies', symbol);
                 optionalPeerDependencyIssues.push({
                     type: 'optionalPeerDependencies',
@@ -369,4 +372,7 @@ export class DependencyDeputy {
     addIgnoredBinaries(workspaceName, identifier) {
         this._manifests.get(workspaceName)?.ignoreBinaries.push(toRegexOrString(identifier));
     }
+    addIgnoredUnresolved(workspaceName, identifier) {
+        this._manifests.get(workspaceName)?.ignoreUnresolved.push(toRegexOrString(identifier));
+    }
 }

package/dist/IssueCollector.d.ts

@@ -1,11 +1,12 @@
 import type { IgnoreIssues } from './types/config.js';
 import type { ConfigurationHint, Issue, TagHint } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
+import type { WorkspaceFilePathFilter } from './util/workspace-file-filter.js';
 export type CollectorIssues = ReturnType<IssueCollector['getIssues']>;
 export declare class IssueCollector {
     private cwd;
     private rules;
-    private filter;
+    private workspaceFilter;
     private issues;
     private counters;
     private referencedFiles;
@@ -17,6 +18,7 @@ export declare class IssueCollector {
     private isFileMatch;
     private issueMatchers;
     constructor(options: MainOptions);
+    setWorkspaceFilter(workspaceFilePathFilter: WorkspaceFilePathFilter | undefined): void;
     addIgnorePatterns(patterns: string[]): void;
     addIgnoreFilesPatterns(patterns: string[]): void;
     setIgnoreIssues(ignoreIssues?: IgnoreIssues): void;

package/dist/IssueCollector.js

@@ -1,7 +1,7 @@
 import picomatch from 'picomatch';
 import { partition } from './util/array.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
-import { join, relative } from './util/path.js';
+import { relative } from './util/path.js';
 const createMatcher = (patterns) => {
     const [negated, positive] = partition(patterns, p => p[0] === '!');
     if (positive.length === 0) {
@@ -14,7 +14,7 @@ const createMatcher = (patterns) => {
 export class IssueCollector {
     cwd;
     rules;
-    filter;
+    workspaceFilter;
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
@@ -28,10 +28,14 @@ export class IssueCollector {
     constructor(options) {
         this.cwd = options.cwd;
         this.rules = options.rules;
-        this.filter = options.workspace ? join(options.cwd, options.workspace) : undefined;
+        this.workspaceFilter = () => true;
         this.isMatch = () => false;
         this.isFileMatch = () => false;
     }
+    setWorkspaceFilter(workspaceFilePathFilter) {
+        if (workspaceFilePathFilter)
+            this.workspaceFilter = workspaceFilePathFilter;
+    }
     addIgnorePatterns(patterns) {
         for (const pattern of patterns)
             this.ignorePatterns.add(pattern);
@@ -71,7 +75,7 @@ export class IssueCollector {
     }
     addFilesIssues(filePaths) {
         for (const filePath of filePaths) {
-            if (this.filter && !filePath.startsWith(`${this.filter}/`))
+            if (!this.workspaceFilter(filePath))
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
@@ -89,7 +93,7 @@ export class IssueCollector {
         }
     }
     addIssue(issue) {
-        if (this.filter && !issue.filePath.startsWith(`${this.filter}/`))
+        if (!this.workspaceFilter(issue.filePath))
             return;
         if (this.isMatch(issue.filePath))
             return;

package/dist/cli.js

@@ -2,7 +2,7 @@ import { fix } from './IssueFixer.js';
 import { run } from './run.js';
 import parseArgs, { helpText } from './util/cli-arguments.js';
 import { createOptions } from './util/create-options.js';
-import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError, isModuleNotFoundError, } from './util/errors.js';
+import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError, isLoaderError, isModuleNotFoundError, } from './util/errors.js';
 import { logError, logWarning } from './util/log.js';
 import { perfObserver } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
@@ -32,7 +32,7 @@ const main = async () => {
         }
         const options = await createOptions({ args });
         const { results } = await run(options);
-        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins } = results;
+        const { issues, counters, tagHints, configurationHints, includedWorkspaceDirs, enabledPlugins, selectedWorkspaces, } = results;
         if (options.isWatch || options.isTrace)
             return;
         const initialData = {
@@ -52,6 +52,7 @@ const main = async () => {
             maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
             options: args['reporter-options'] ?? '',
             preprocessorOptions: args['preprocessor-options'] ?? '',
+            selectedWorkspaces,
         };
         const finalData = await runPreprocessors(args.preprocessor ?? [], initialData);
         if (options.isFix)
@@ -92,6 +93,8 @@ const main = async () => {
                 console.error('Reason:', knownErrors[0].cause.message);
                 if (isModuleNotFoundError(knownErrors[0].cause))
                     console.log('Module load error? Visit https://knip.dev/reference/known-issues');
+                if (isLoaderError(knownErrors[0]))
+                    console.log('Configuration file load error? Visit https://knip.dev/reference/known-issues');
             }
             if (isConfigurationError(knownErrors[0]))
                 console.log('\nRun `knip --help` or visit https://knip.dev for help');

package/dist/compilers/astro-mdx.js

@@ -1,9 +1,9 @@
-import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter } from './compilers.js';
+import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter, inlineCodeMatcher } from './compilers.js';
 const astroMDXDependencies = ['@astrojs/mdx', '@astrojs/starlight'];
 const frontmatterImportFields = ['layout'];
 const condition = (hasDependency) => astroMDXDependencies.some(hasDependency);
 const compiler = (text) => {
-    const imports = text.replace(fencedCodeBlockMatcher, '').matchAll(importMatcher);
+    const imports = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '').matchAll(importMatcher);
     const frontmatterImports = importsWithinFrontmatter(text, frontmatterImportFields);
     return [...imports, frontmatterImports].join('\n');
 };

package/dist/compilers/compilers.d.ts

@@ -1,5 +1,6 @@
 import type { SyncCompilerFn } from './types.js';
 export declare const fencedCodeBlockMatcher: RegExp;
+export declare const inlineCodeMatcher: RegExp;
 export declare const importMatcher: RegExp;
 export declare const importsWithinScripts: SyncCompilerFn;
 export declare const scriptBodies: SyncCompilerFn;

package/dist/compilers/compilers.js

@@ -1,4 +1,5 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
+export const inlineCodeMatcher = /`[^`]+`/g;
 const scriptExtractor = /<script\b[^>]*>([\s\S]*?)<\/script>/gm;
 export const importMatcher = /import[^'"]+['"][^'"]+['"]/g;
 export const importsWithinScripts = (text) => {

package/dist/compilers/index.d.ts

@@ -2,7 +2,7 @@ import type { RawConfiguration } from '../types/config.js';
 import type { DependencySet } from '../types/workspace.js';
 import type { AsyncCompilerFn, AsyncCompilers, RawSyncCompilers, SyncCompilerFn, SyncCompilers } from './types.js';
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
-    syncCompilers: Record<string, SyncCompilerFn>;
+    syncCompilers: Record<string, true | SyncCompilerFn>;
     asyncCompilers: Record<string, AsyncCompilerFn>;
     angular?: string | boolean | string[] | {
         config?: string | string[] | undefined;
@@ -299,6 +299,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    nitro?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     node?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -499,6 +504,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    sveltekit?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     svgo?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -940,6 +950,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        nitro?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1140,6 +1155,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        sveltekit?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         svgo?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/index.js

@@ -22,6 +22,9 @@ export const partitionCompilers = (rawLocalConfig) => {
                 syncCompilers[ext] = compilerFn;
             }
         }
+        else if (compilerFn === true) {
+            syncCompilers[ext] = true;
+        }
     }
     for (const extension in rawLocalConfig.asyncCompilers) {
         const ext = normalizeExt(extension);

package/dist/compilers/mdx.js

@@ -1,4 +1,4 @@
-import { fencedCodeBlockMatcher, importMatcher } from './compilers.js';
+import { fencedCodeBlockMatcher, importMatcher, inlineCodeMatcher } from './compilers.js';
 const mdxDependencies = [
     '@mdx-js/esbuild',
     '@mdx-js/loader',
@@ -11,5 +11,5 @@ const mdxDependencies = [
     'remark-mdx',
 ];
 const condition = (hasDependency) => mdxDependencies.some(hasDependency);
-const compiler = (text) => [...text.replace(fencedCodeBlockMatcher, '').matchAll(importMatcher)].join('\n');
+const compiler = (text) => [...text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '').matchAll(importMatcher)].join('\n');
 export default { condition, compiler };

package/dist/graph/analyze.js

@@ -234,7 +234,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
-    if (options.isTrace)
-        traceReporter({ graph, explorer, options });
+    if (options.isTrace) {
+        traceReporter({ graph, explorer, options, workspaceFilePathFilter: chief.workspaceFilePathFilter });
+    }
     return analyzeGraph;
 };

package/dist/graph/build.js

@@ -150,6 +150,9 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 else if (input.issueType === 'binaries') {
                     deputy.addIgnoredBinaries(name, input.specifier);
                 }
+                else if (input.issueType === 'unresolved') {
+                    deputy.addIgnoredUnresolved(name, input.specifier);
+                }
             }
             else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export declare const main: (options: MainOptions) => Promise<{
     counters: import("./types/issues.js").Counters;
     tagHints: Set<import("./types/issues.js").TagHint>;
     configurationHints: import("./types/issues.js").ConfigurationHint[];
+    selectedWorkspaces: string[] | undefined;
     includedWorkspaceDirs: string[];
     enabledPlugins: {
         [k: string]: string[];

package/dist/plugins/github-actions/index.js

@@ -1,10 +1,12 @@
-import { _firstGlob } from '../../util/glob.js';
+import { hasFilesWithExtensions } from '../../util/fs.js';
 import { isDeferResolveEntry, toEntry } from '../../util/input.js';
 import { findByKeyDeep } from '../../util/object.js';
 import { join, relative } from '../../util/path.js';
 const title = 'GitHub Actions';
 const enablers = 'This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.';
-const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.{yml,yaml}'] }));
+const isEnabled = ({ cwd }) => {
+    return hasFilesWithExtensions(cwd, '.github/workflows', ['yml', 'yaml']);
+};
 const isRootOnly = true;
 const config = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
 const isString = (value) => typeof value === 'string';