knip 5.71.0 → 5.72.0

package/dist/ConfigurationChief.d.ts

@@ -527,6 +527,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgr?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -761,6 +766,7 @@ export declare class ConfigurationChief {
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svgo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        svgr?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         taskfile?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ConsoleStreamer.js

@@ -3,7 +3,7 @@ export class ConsoleStreamer {
     isWatch = false;
     lines = 0;
     constructor(options) {
-        this.isEnabled = options.isShowProgress && !options.isDebug;
+        this.isEnabled = options.isShowProgress;
         this.isWatch = options.isWatch;
     }
     clearLines(count) {

package/dist/compilers/index.d.ts

@@ -479,6 +479,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    svgr?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     syncpack?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1075,6 +1080,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgr?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/index.js

@@ -2,6 +2,7 @@ import Astro from './astro.js';
 import AstroMDX from './astro-mdx.js';
 import MDX from './mdx.js';
 import Prisma from './prisma.js';
+import SCSS from './scss.js';
 import Svelte from './svelte.js';
 import CSS from './tailwind.js';
 import Vue from './vue.js';
@@ -33,6 +34,8 @@ const compilers = new Map([
     ['.css', CSS],
     ['.mdx', MDX],
     ['.prisma', Prisma],
+    ['.sass', SCSS],
+    ['.scss', SCSS],
     ['.svelte', Svelte],
     ['.vue', Vue],
 ]);

package/dist/compilers/scss.d.ts

@@ -0,0 +1,6 @@
+import type { HasDependency } from './types.js';
+declare const _default: {
+    condition: (hasDependency: HasDependency) => boolean;
+    compiler: (text: string) => string;
+};
+export default _default;

package/dist/compilers/scss.js

@@ -0,0 +1,14 @@
+const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
+const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
+const toRelative = (specifier) => (specifier.startsWith('.') ? specifier : `./${specifier}`);
+const compiler = (text) => {
+    const imports = [];
+    let match;
+    let index = 0;
+    while ((match = importMatcher.exec(text))) {
+        if (match[2])
+            imports.push(`import _$${index++} from '${match[1] ? match[2] : toRelative(match[2])}';`);
+    }
+    return imports.join('\n');
+};
+export default { condition, compiler };

package/dist/graph/analyze.js

@@ -1,16 +1,17 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
 import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
+import { toRelative } from '../util/path.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
-import { printTraceNode } from '../util/trace.js';
+import { formatTrace } from '../util/trace.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
     const explorer = createGraphExplorer(graph, entryPaths);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
-    const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
-        (exportedItem.refs[0] > 0 &&
+    const isExportReferencedInFile = (exportedItem) => exportedItem.self[1] ||
+        (exportedItem.self[0] > 0 &&
             (typeof ignoreExportsUsedInFile === 'object'
                 ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
                 : ignoreExportsUsedInFile));
@@ -38,7 +39,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
                                 includeEntryExports: isIncludeEntryExports,
                             });
-                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                            if ((isReferenced || exportedItem.self[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
@@ -47,7 +48,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             }
                             if (isIgnored)
                                 continue;
-                            if (reExportingEntryFile) {
+                            if (reExportingEntryFile && !isReferenced) {
                                 if (!isIncludeEntryExports) {
                                     continue;
                                 }
@@ -66,7 +67,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             continue;
                                         if (shouldIgnore(member.jsDocTags))
                                             continue;
-                                        if (member.refs[0] === 0) {
+                                        if (member.self[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
                                             const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
                                                 includeEntryExports: true,
@@ -130,7 +131,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         if (hasStrictlyNsRefs &&
                             ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
                             continue;
-                        if (!isExportedItemReferenced(exportedItem)) {
+                        if (!isExportReferencedInFile(exportedItem)) {
                             if (isIgnored)
                                 continue;
                             if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
@@ -229,8 +230,18 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     await analyzeGraph();
     if (options.isTrace) {
         const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
+        nodes.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.identifier.localeCompare(b.identifier));
+        const toRel = (path) => toRelative(path, options.cwd);
+        const isReferenced = (node) => {
+            if (explorer.isReferenced(node.filePath, node.identifier, { includeEntryExports: false })[0])
+                return true;
+            if (explorer.hasStrictlyNsReferences(node.filePath, node.identifier)[0])
+                return true;
+            const exportItem = graph.get(node.filePath)?.exports.get(node.identifier);
+            return exportItem ? isExportReferencedInFile(exportItem) : false;
+        };
         for (const node of nodes)
-            printTraceNode(node, options);
+            console.log(formatTrace(node, toRel, isReferenced(node)));
     }
     return analyzeGraph;
 };

package/dist/graph-explorer/explorer.d.ts

@@ -7,5 +7,5 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     buildExportsTree: (options: {
         filePath?: string;
         identifier?: string;
-    }) => import("./operations/build-trace-tree.js").TreeNode[];
+    }) => import("./operations/build-exports-tree.js").TreeNode[];
 };

package/dist/graph-explorer/explorer.js

@@ -1,4 +1,4 @@
-import { buildExportsTree } from './operations/build-trace-tree.js';
+import { buildExportsTree } from './operations/build-exports-tree.js';
 import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
 import { isReferenced } from './operations/is-referenced.js';
 export const createGraphExplorer = (graph, entryPaths) => {

package/dist/graph-explorer/operations/{build-trace-tree.d.ts → build-exports-tree.d.ts}

@@ -1,8 +1,11 @@
 import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+import type { Via } from '../walk-down.js';
 export interface TreeNode {
     filePath: string;
     identifier: string;
-    hasRef: boolean;
+    originalId: string | undefined;
+    via: Via | undefined;
+    refs: string[];
     isEntry: boolean;
     children: TreeNode[];
 }

package/dist/graph-explorer/operations/build-exports-tree.js

@@ -0,0 +1,96 @@
+import { CONTINUE } from '../constants.js';
+import { walkDown } from '../walk-down.js';
+export const buildExportsTree = (graph, entryPaths, options) => {
+    const traces = [];
+    const processFile = (filePath, file) => {
+        for (const exportId of options.identifier ? [options.identifier] : file.exports.keys()) {
+            if (!options.identifier || file.exports.has(exportId)) {
+                const trace = buildExportTree(graph, entryPaths, filePath, exportId);
+                if (trace)
+                    traces.push(trace);
+            }
+        }
+    };
+    if (options.filePath) {
+        const file = graph.get(options.filePath);
+        if (file)
+            processFile(options.filePath, file);
+    }
+    else {
+        for (const [filePath, file] of graph)
+            processFile(filePath, file);
+    }
+    return traces;
+};
+const buildExportTree = (graph, entryPaths, filePath, identifier) => {
+    const file = graph.get(filePath);
+    const rootNode = {
+        filePath,
+        identifier,
+        refs: filterRefs(file?.imported?.refs, identifier),
+        isEntry: entryPaths.has(filePath),
+        children: [],
+        originalId: undefined,
+        via: undefined,
+    };
+    const nodeMap = new Map();
+    nodeMap.set(`${filePath}:${identifier}`, rootNode);
+    walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, via) => {
+        const importMaps = graph.get(importingFile)?.imports.internal.get(sourceFile);
+        const importRefs = importMaps?.refs;
+        const ns = id.split('.')[0];
+        if (via === 'importNS' && !hasRelevantRef(importRefs, id) && !isNsReExported(importMaps, ns))
+            return CONTINUE;
+        const key = `${importingFile}:${id}`;
+        const isRenamed = via.endsWith('As') && sourceId !== ns;
+        const refs = filterRefs(importRefs, id);
+        const childNode = nodeMap.get(key) ?? {
+            filePath: importingFile,
+            identifier: id,
+            originalId: isRenamed ? sourceId : undefined,
+            via,
+            refs,
+            isEntry,
+            children: [],
+        };
+        nodeMap.set(key, childNode);
+        let parentNode = nodeMap.get(`${sourceFile}:${sourceId}`);
+        if (!parentNode) {
+            for (const [k, v] of nodeMap) {
+                if (k.startsWith(`${sourceFile}:${sourceId}.`) || k === `${sourceFile}:${sourceId}`) {
+                    parentNode = v;
+                    break;
+                }
+            }
+        }
+        (parentNode ?? rootNode).children.push(childNode);
+        return CONTINUE;
+    }, entryPaths);
+    pruneReExportStarOnlyBranches(rootNode);
+    return rootNode;
+};
+const filterRefs = (refs, id) => {
+    if (!refs)
+        return [];
+    return Array.from(refs).filter(ref => id === ref || id.startsWith(`${ref}.`) || ref.startsWith(`${id}.`));
+};
+const hasRelevantRef = (refs, id) => {
+    if (!refs || refs.size === 0)
+        return false;
+    return Array.from(refs).some(ref => ref === id || ref.startsWith(`${id}.`));
+};
+const isNsReExported = (importMaps, ns) => {
+    if (!importMaps)
+        return false;
+    return importMaps.reExportedAs.has(ns) || importMaps.reExportedNs.has(ns);
+};
+const hasNonReExportStar = (node) => {
+    if (node.via && node.via !== 'reExportStar')
+        return true;
+    return node.children.some(child => hasNonReExportStar(child));
+};
+const pruneReExportStarOnlyBranches = (node) => {
+    node.children = node.children.filter(child => hasNonReExportStar(child));
+    for (const child of node.children)
+        pruneReExportStarOnlyBranches(child);
+};

package/dist/graph-explorer/operations/is-referenced.js

@@ -5,8 +5,6 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const check = (currentPath, currentId) => {
         const isEntryFile = entryPaths.has(currentPath);
         let reExportingEntryFile = isEntryFile ? currentPath : undefined;
-        if (isEntryFile && !options.includeEntryExports)
-            return [false, reExportingEntryFile];
         if (seen.has(currentPath))
             return [false, reExportingEntryFile];
         seen.add(currentPath);
@@ -16,8 +14,6 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         if (!identifier || !file) {
             return [false, reExportingEntryFile];
         }
-        const directSources = getPassThroughReExportSources(file, identifier);
-        const starSources = getStarReExportSources(file);
         const followSources = (sources, nextId) => {
             for (const byFilePath of sources) {
                 if (seen.has(byFilePath))
@@ -62,6 +58,8 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                     return [true, reExportingEntryFile];
             }
         }
+        if (isEntryFile && !options.includeEntryExports)
+            return [false, reExportingEntryFile];
         const aliasMap = getAliasReExportMap(file, identifier);
         if (aliasMap) {
             for (const [alias, sources] of aliasMap) {
@@ -70,6 +68,8 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                     return [true, reExportingEntryFile];
             }
         }
+        const directSources = getPassThroughReExportSources(file, identifier);
+        const starSources = getStarReExportSources(file);
         if (directSources) {
             if (followSources(directSources, currentId))
                 return [true, reExportingEntryFile];

package/dist/graph-explorer/utils.d.ts

@@ -1,4 +1,3 @@
-import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
-export declare const hasNamespaceMemberReference: (graph: ModuleGraph, importingFile: string, importedFile: string, namespace: string, member: string) => boolean | null;
+import type { ImportMaps } from '../types/module-graph.js';
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
 export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/graph-explorer/utils.js

@@ -1,18 +1,3 @@
-import { OPAQUE } from '../constants.js';
-export const hasNamespaceMemberReference = (graph, importingFile, importedFile, namespace, member) => {
-    const importerNode = graph.get(importingFile);
-    if (!importerNode)
-        return null;
-    const importMap = importerNode.imports.internal.get(importedFile);
-    if (!importMap)
-        return null;
-    if (importMap.imported.get(OPAQUE))
-        return true;
-    if (importMap.refs.size === 0)
-        return false;
-    const refKey = member ? `${namespace}.${member}` : namespace;
-    return refKey ? importMap.refs.has(refKey) : null;
-};
 export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
     if (!importsForExport || !importsForExport.refs.has(identifier))
         return false;

package/dist/graph-explorer/walk-down.d.ts

@@ -1,4 +1,5 @@
 import type { ModuleGraph } from '../types/module-graph.js';
-type Visitor = (sourceFile: string, identifier: string, importingFile: string, identifierPath: string, isEntry: boolean, isReExport: boolean) => 'continue' | 'stop' | undefined;
+export type Via = 'import' | 'importAs' | 'importNS' | 'reExport' | 'reExportAs' | 'reExportNS' | 'reExportStar';
+type Visitor = (sourceFile: string, identifier: string, importingFile: string, identifierPath: string, isEntry: boolean, via: Via) => 'continue' | 'stop' | undefined;
 export declare const walkDown: (graph: ModuleGraph, filePath: string, identifier: string, visitor: Visitor, entryPaths: Set<string>, visited?: Set<string>) => boolean;
 export {};

package/dist/graph-explorer/walk-down.js

@@ -1,5 +1,4 @@
 import { STOP } from './constants.js';
-import { hasNamespaceMemberReference } from './utils.js';
 import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from './visitors.js';
 export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visited = new Set()) => {
     const key = `${filePath}:${identifier}`;
@@ -18,7 +17,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
     if (importedByFiles) {
         for (const importingFile of importedByFiles) {
             const isEntry = entryPaths.has(importingFile);
-            if (visitor(filePath, id, importingFile, id, isEntry, false) === STOP)
+            if (visitor(filePath, id, importingFile, id, isEntry, 'import') === STOP)
                 return true;
         }
     }
@@ -27,17 +26,15 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         for (const [alias, byFilePaths] of importedAsAliases) {
             for (const importingFile of byFilePaths) {
                 const isEntry = entryPaths.has(importingFile);
-                if (visitor(filePath, id, importingFile, alias, isEntry, false) === STOP)
+                if (visitor(filePath, id, importingFile, alias, isEntry, 'importAs') === STOP)
                     return true;
             }
         }
     }
     for (const [namespace, byFilePaths] of imported.importedNs) {
         for (const importingFile of byFilePaths) {
-            if (hasNamespaceMemberReference(graph, importingFile, filePath, namespace, identifier) === false)
-                continue;
             const isEntry = entryPaths.has(importingFile);
-            if (visitor(filePath, identifier, importingFile, `${namespace}.${identifier}`, isEntry, false) === STOP) {
+            if (visitor(filePath, identifier, importingFile, `${namespace}.${identifier}`, isEntry, 'importNS') === STOP) {
                 return true;
             }
         }
@@ -48,7 +45,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         if (passThroughSources) {
             for (const reExportingFile of passThroughSources) {
                 const isEntry = entryPaths.has(reExportingFile);
-                if (visitor(filePath, id, reExportingFile, id, isEntry, true) === STOP) {
+                if (visitor(filePath, id, reExportingFile, id, isEntry, 'reExport') === STOP) {
                     done = true;
                     break;
                 }
@@ -65,7 +62,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
             for (const [alias, sources] of aliasReExportMap) {
                 for (const reExportingFile of sources) {
                     const isEntry = entryPaths.has(reExportingFile);
-                    if (visitor(filePath, id, reExportingFile, alias, isEntry, true) === STOP) {
+                    if (visitor(filePath, id, reExportingFile, alias, isEntry, 'reExportAs') === STOP) {
                         done = true;
                         break;
                     }
@@ -86,7 +83,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         for (const [namespace, sources] of imported.reExportedNs) {
             for (const reExportingFile of sources) {
                 const isEntry = entryPaths.has(reExportingFile);
-                if (visitor(filePath, identifier, reExportingFile, `${namespace}.${identifier}`, isEntry, true) === STOP) {
+                if (visitor(filePath, identifier, reExportingFile, `${namespace}.${identifier}`, isEntry, 'reExportNS') === STOP) {
                     done = true;
                     break;
                 }
@@ -104,7 +101,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         if (starSources) {
             for (const reExportingFile of starSources) {
                 const isEntry = entryPaths.has(reExportingFile);
-                if (visitor(filePath, id, reExportingFile, id, isEntry, true) === STOP) {
+                if (visitor(filePath, id, reExportingFile, id, isEntry, 'reExportStar') === STOP) {
                     done = true;
                     break;
                 }

package/dist/plugins/index.d.ts

@@ -94,6 +94,7 @@ export declare const Plugins: {
     stylelint: import("../types/config.js").Plugin;
     svelte: import("../types/config.js").Plugin;
     svgo: import("../types/config.js").Plugin;
+    svgr: import("../types/config.js").Plugin;
     syncpack: import("../types/config.js").Plugin;
     tailwind: import("../types/config.js").Plugin;
     taskfile: import("../types/config.js").Plugin;

package/dist/plugins/index.js

@@ -93,6 +93,7 @@ import { default as stryker } from './stryker/index.js';
 import { default as stylelint } from './stylelint/index.js';
 import { default as svelte } from './svelte/index.js';
 import { default as svgo } from './svgo/index.js';
+import { default as svgr } from './svgr/index.js';
 import { default as syncpack } from './syncpack/index.js';
 import { default as tailwind } from './tailwind/index.js';
 import { default as taskfile } from './taskfile/index.js';
@@ -213,6 +214,7 @@ export const Plugins = {
     stylelint,
     svelte,
     svgo,
+    svgr,
     syncpack,
     tailwind,
     taskfile,

package/dist/plugins/rsbuild/index.js

@@ -23,6 +23,14 @@ const resolveConfig = async (config) => {
                 }
             }
         }
+        if (source?.preEntry) {
+            const entry = source.preEntry;
+            if (typeof entry === 'string')
+                entries.add(entry);
+            else if (Array.isArray(entry))
+                for (const e of entry)
+                    entries.add(e);
+        }
     };
     checkSource(config.source);
     if (config.environments) {

package/dist/plugins/rsbuild/types.d.ts

@@ -6,6 +6,7 @@ export type RsbuildConfig = {
     plugins?: unknown[];
     source?: {
         entry?: Entry;
+        preEntry?: string | string[];
     };
     environments?: {
         [k: string]: Pick<RsbuildConfig, 'plugins' | 'source'>;

package/dist/plugins/storybook/index.js

@@ -1,4 +1,4 @@
-import { toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Storybook';
@@ -10,7 +10,7 @@ const restEntry = ['.{storybook,rnstorybook}/{manager,preview,index,vitest.setup
 const entry = [...restEntry, ...stories];
 const project = ['.{storybook,rnstorybook}/**/*.{js,jsx,ts,tsx,mts}'];
 const resolveConfig = async (localConfig, options) => {
-    const { cwd, configFileDir } = options;
+    const { cwd, configFileDir, configFilePath } = options;
     const strs = typeof localConfig?.stories === 'function' ? await localConfig.stories(stories) : localConfig?.stories;
     const relativePatterns = strs?.map(pattern => {
         if (typeof pattern === 'string')
@@ -29,13 +29,21 @@ const resolveConfig = async (localConfig, options) => {
             ? [`@storybook/builder-${builder}`, `@storybook/manager-${builder}`]
             : [builder]
         : [];
-    const framework = typeof localConfig.framework === 'string' ? localConfig.framework : localConfig.framework?.name;
-    const frameworks = framework ? [framework] : [];
+    const framework = localConfig.framework;
+    const frameworkName = typeof framework === 'string' ? framework : framework?.name;
+    const frameworks = frameworkName ? [frameworkName] : [];
+    const viteConfigPath = typeof framework === 'object' &&
+        framework?.name === '@storybook/react-vite' &&
+        framework?.options?.builder?.viteConfigPath;
+    const configs = viteConfigPath
+        ? [toConfig('vite', viteConfigPath, { dir: cwd, containingFilePath: configFilePath })]
+        : [];
     return [
         ...patterns.map(id => toEntry(id)),
         ...addons.map(id => toDeferResolve(id)),
         ...builderPackages.map(id => toDependency(id)),
         ...frameworks.map(id => toDependency(id)),
+        ...configs,
     ];
 };
 const plugin = {

package/dist/plugins/storybook/types.d.ts

@@ -15,6 +15,11 @@ export type StorybookConfig = {
     };
     framework?: string | {
         name?: string;
+        options?: {
+            builder?: {
+                viteConfigPath?: string;
+            };
+        };
     };
 };
 export {};

package/dist/plugins/svgo/index.js

@@ -1,6 +1,6 @@
 import { hasDependency } from '../../util/plugin.js';
 const title = 'SVGO';
-const enablers = ['svgo'];
+const enablers = ['svgo', '@svgr/plugin-svgo'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['svgo.config.{js,cjs,mjs}'];
 const plugin = {

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/svgr/index.js

@@ -0,0 +1,24 @@
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'SVGR';
+const enablers = ['@svgr/cli', '@svgr/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.svgrrc', '.svgrrc.{yaml,yml,json,js}', 'svgr.config.{js,cjs}', 'package.json'];
+const resolveConfig = async (config) => {
+    const inputs = [];
+    if (config.plugins) {
+        for (const plugin of config.plugins) {
+            if (typeof plugin === 'string')
+                inputs.push(toDependency(plugin));
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/svgr/types.d.ts

@@ -0,0 +1,3 @@
+export type SvgrConfig = {
+    plugins?: (string | unknown)[];
+};

package/dist/plugins/svgr/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/vite/index.js

@@ -10,6 +10,9 @@ const resolveFromAST = (sourceFile) => {
     const babelPlugins = getReactBabelPlugins(sourceFile);
     return babelPlugins.map(plugin => toDependency(plugin));
 };
+const args = {
+    config: true,
+};
 const plugin = {
     title,
     enablers,
@@ -17,5 +20,6 @@ const plugin = {
     config,
     resolveConfig,
     resolveFromAST,
+    args,
 };
 export default plugin;

package/dist/plugins/vitest/index.js

@@ -13,7 +13,7 @@ const entry = ['**/*.{bench,test,test-d,spec}.?(c|m)[jt]s?(x)', ...mocks];
 const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
 const hasScriptWithCoverage = (scripts) => scripts ? Object.values(scripts).some(script => isVitestCoverageCommand.test(script)) : false;
 const findConfigDependencies = (localConfig, options) => {
-    const { manifest, cwd: dir } = options;
+    const { manifest, configFileDir: dir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];

package/dist/schema/configuration.d.ts

@@ -477,6 +477,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>]>>;
+    svgr: 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>]>>;
     syncpack: 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>>]>>;
@@ -1073,6 +1078,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>]>>;
+        svgr: 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>]>>;
         syncpack: 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>>]>>;