knip 5.70.2 → 5.72.0

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

@@ -0,0 +1,89 @@
+import { OPAQUE } from '../../constants.js';
+import { getAliasReExportMap, getNamespaceReExportSources, getPassThroughReExportSources, getStarReExportSources, } from '../visitors.js';
+export const isReferenced = (graph, entryPaths, filePath, id, options) => {
+    const seen = new Set();
+    const check = (currentPath, currentId) => {
+        const isEntryFile = entryPaths.has(currentPath);
+        let reExportingEntryFile = isEntryFile ? currentPath : undefined;
+        if (seen.has(currentPath))
+            return [false, reExportingEntryFile];
+        seen.add(currentPath);
+        const restIds = currentId.split('.');
+        const identifier = restIds.shift();
+        const file = graph.get(currentPath)?.imported;
+        if (!identifier || !file) {
+            return [false, reExportingEntryFile];
+        }
+        const followSources = (sources, nextId) => {
+            for (const byFilePath of sources) {
+                if (seen.has(byFilePath))
+                    continue;
+                const result = check(byFilePath, nextId);
+                if (result[1])
+                    reExportingEntryFile = result[1];
+                if (result[0])
+                    return true;
+            }
+            return false;
+        };
+        if (file.imported.get(OPAQUE) ||
+            ((identifier === currentId || (identifier !== currentId && file.refs.has(currentId))) &&
+                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
+            return [true, reExportingEntryFile];
+        }
+        for (const [exportId, aliases] of file.importedAs) {
+            if (identifier === exportId) {
+                for (const alias of aliases.keys()) {
+                    const aliasedRef = [alias, ...restIds].join('.');
+                    if (file.refs.has(aliasedRef)) {
+                        return [true, reExportingEntryFile];
+                    }
+                }
+            }
+        }
+        for (const namespace of file.importedNs.keys()) {
+            if (file.refs.has(`${namespace}.${currentId}`)) {
+                return [true, reExportingEntryFile];
+            }
+            const nsAliasMap = getAliasReExportMap(file, namespace);
+            if (nsAliasMap) {
+                for (const [alias, sources] of nsAliasMap) {
+                    if (followSources(sources, `${alias}.${currentId}`))
+                        return [true, reExportingEntryFile];
+                }
+            }
+            const nsReExportSources = getNamespaceReExportSources(file, namespace);
+            if (nsReExportSources) {
+                if (followSources(nsReExportSources, `${namespace}.${currentId}`))
+                    return [true, reExportingEntryFile];
+            }
+        }
+        if (isEntryFile && !options.includeEntryExports)
+            return [false, reExportingEntryFile];
+        const aliasMap = getAliasReExportMap(file, identifier);
+        if (aliasMap) {
+            for (const [alias, sources] of aliasMap) {
+                const ref = [alias, ...restIds].join('.');
+                if (followSources(sources, ref))
+                    return [true, reExportingEntryFile];
+            }
+        }
+        const directSources = getPassThroughReExportSources(file, identifier);
+        const starSources = getStarReExportSources(file);
+        if (directSources) {
+            if (followSources(directSources, currentId))
+                return [true, reExportingEntryFile];
+        }
+        else if (starSources) {
+            if (followSources(starSources, currentId))
+                return [true, reExportingEntryFile];
+        }
+        for (const [namespace, sources] of file.reExportedNs) {
+            if (followSources(sources, `${namespace}.${currentId}`)) {
+                return [true, reExportingEntryFile];
+            }
+        }
+        return [false, reExportingEntryFile];
+    };
+    return check(filePath, id);
+};

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,13 @@
+export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
+    if (!importsForExport || !importsForExport.refs.has(identifier))
+        return false;
+    for (const ref of importsForExport.refs)
+        if (ref.startsWith(`${identifier}.`))
+            return false;
+    return true;
+};
+export const getIssueType = (hasOnlyNsReference, isType) => {
+    if (hasOnlyNsReference)
+        return isType ? 'nsTypes' : 'nsExports';
+    return isType ? 'types' : 'exports';
+};

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

@@ -0,0 +1,12 @@
+import type { ImportMaps } from '../types/module-graph.js';
+type PassThroughReExportCallback = (identifier: string, sources: Set<string>) => boolean | void;
+type AliasReExportCallback = (identifier: string, alias: string, sources: Set<string>) => boolean | void;
+type NamespaceReExportCallback = (namespace: string, sources: Set<string>) => boolean | void;
+export declare const forEachPassThroughReExport: (importMaps: ImportMaps, callback: PassThroughReExportCallback) => boolean;
+export declare const forEachAliasReExport: (importMaps: ImportMaps, callback: AliasReExportCallback) => boolean;
+export declare const forEachNamespaceReExport: (importMaps: ImportMaps, callback: NamespaceReExportCallback) => boolean;
+export declare const getStarReExportSources: (importMaps: ImportMaps) => Set<string> | undefined;
+export declare const getPassThroughReExportSources: (importMaps: ImportMaps, identifier: string) => Set<string> | undefined;
+export declare const getAliasReExportMap: (importMaps: ImportMaps, identifier: string) => Map<string, Set<string>> | undefined;
+export declare const getNamespaceReExportSources: (importMaps: ImportMaps, namespace: string) => Set<string> | undefined;
+export {};

package/dist/graph-explorer/visitors.js

@@ -0,0 +1,30 @@
+import { IMPORT_STAR } from '../constants.js';
+export const forEachPassThroughReExport = (importMaps, callback) => {
+    for (const [identifier, sources] of importMaps.reExported) {
+        if (identifier === IMPORT_STAR)
+            continue;
+        if (callback(identifier, sources ?? new Set()) === false)
+            return false;
+    }
+    return true;
+};
+export const forEachAliasReExport = (importMaps, callback) => {
+    for (const [identifier, aliasMap] of importMaps.reExportedAs) {
+        for (const [alias, sources] of aliasMap) {
+            if (callback(identifier, alias, sources ?? new Set()) === false)
+                return false;
+        }
+    }
+    return true;
+};
+export const forEachNamespaceReExport = (importMaps, callback) => {
+    for (const [namespace, sources] of importMaps.reExportedNs) {
+        if (callback(namespace, sources ?? new Set()) === false)
+            return false;
+    }
+    return true;
+};
+export const getStarReExportSources = (importMaps) => importMaps.reExported.get(IMPORT_STAR);
+export const getPassThroughReExportSources = (importMaps, identifier) => importMaps.reExported.get(identifier);
+export const getAliasReExportMap = (importMaps, identifier) => importMaps.reExportedAs.get(identifier);
+export const getNamespaceReExportSources = (importMaps, namespace) => importMaps.reExportedNs.get(namespace);

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

@@ -0,0 +1,5 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+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

@@ -0,0 +1,116 @@
+import { STOP } from './constants.js';
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from './visitors.js';
+export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visited = new Set()) => {
+    const key = `${filePath}:${identifier}`;
+    if (visited.has(key))
+        return false;
+    visited.add(key);
+    const file = graph.get(filePath);
+    if (!file?.imported)
+        return false;
+    const restIds = identifier.split('.');
+    const id = restIds.shift();
+    if (!id)
+        return false;
+    const imported = file.imported;
+    const importedByFiles = imported.imported.get(id);
+    if (importedByFiles) {
+        for (const importingFile of importedByFiles) {
+            const isEntry = entryPaths.has(importingFile);
+            if (visitor(filePath, id, importingFile, id, isEntry, 'import') === STOP)
+                return true;
+        }
+    }
+    const importedAsAliases = imported.importedAs.get(id);
+    if (importedAsAliases) {
+        for (const [alias, byFilePaths] of importedAsAliases) {
+            for (const importingFile of byFilePaths) {
+                const isEntry = entryPaths.has(importingFile);
+                if (visitor(filePath, id, importingFile, alias, isEntry, 'importAs') === STOP)
+                    return true;
+            }
+        }
+    }
+    for (const [namespace, byFilePaths] of imported.importedNs) {
+        for (const importingFile of byFilePaths) {
+            const isEntry = entryPaths.has(importingFile);
+            if (visitor(filePath, identifier, importingFile, `${namespace}.${identifier}`, isEntry, 'importNS') === STOP) {
+                return true;
+            }
+        }
+    }
+    let done = false;
+    if (!done) {
+        const passThroughSources = getPassThroughReExportSources(imported, id);
+        if (passThroughSources) {
+            for (const reExportingFile of passThroughSources) {
+                const isEntry = entryPaths.has(reExportingFile);
+                if (visitor(filePath, id, reExportingFile, id, isEntry, 'reExport') === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, identifier, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (!done) {
+        const aliasReExportMap = getAliasReExportMap(imported, id);
+        if (aliasReExportMap) {
+            for (const [alias, sources] of aliasReExportMap) {
+                for (const reExportingFile of sources) {
+                    const isEntry = entryPaths.has(reExportingFile);
+                    if (visitor(filePath, id, reExportingFile, alias, isEntry, 'reExportAs') === STOP) {
+                        done = true;
+                        break;
+                    }
+                    if (!isEntry) {
+                        const ref = [alias, ...restIds].join('.');
+                        if (walkDown(graph, reExportingFile, ref, visitor, entryPaths, visited)) {
+                            done = true;
+                            break;
+                        }
+                    }
+                }
+                if (done)
+                    break;
+            }
+        }
+    }
+    if (!done) {
+        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, 'reExportNS') === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, `${namespace}.${identifier}`, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    if (!done) {
+        const starSources = getStarReExportSources(imported);
+        if (starSources) {
+            for (const reExportingFile of starSources) {
+                const isEntry = entryPaths.has(reExportingFile);
+                if (visitor(filePath, id, reExportingFile, id, isEntry, 'reExportStar') === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, identifier, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+        }
+    }
+    return done;
+};

package/dist/index.js

@@ -1,98 +1,2 @@
-import { watch } from 'node:fs';
-import { formatly } from 'formatly';
-import { CatalogCounselor } from './CatalogCounselor.js';
-import { ConfigurationChief } from './ConfigurationChief.js';
-import { ConsoleStreamer } from './ConsoleStreamer.js';
-import { DependencyDeputy } from './DependencyDeputy.js';
-import { analyze } from './graph/analyze.js';
-import { build } from './graph/build.js';
-import { IssueCollector } from './IssueCollector.js';
-import { IssueFixer } from './IssueFixer.js';
-import { PrincipalFactory } from './PrincipalFactory.js';
-import watchReporter from './reporters/watch.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
-import { getGitIgnoredHandler } from './util/glob-core.js';
-import { getWatchHandler } from './util/watch.js';
-export const main = async (options) => {
-    debugLogObject('*', 'Unresolved configuration', options);
-    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
-    const chief = new ConfigurationChief(options);
-    const deputy = new DependencyDeputy(options);
-    const factory = new PrincipalFactory();
-    const streamer = new ConsoleStreamer(options);
-    const fixer = new IssueFixer(options);
-    const collector = new IssueCollector(options);
-    const counselor = new CatalogCounselor(options);
-    streamer.cast('Reading workspace configuration');
-    const workspaces = await chief.getWorkspaces();
-    const isGitIgnored = await getGitIgnoredHandler(options);
-    collector.setIgnoreIssues(chief.config.ignoreIssues);
-    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
-    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
-    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
-        chief,
-        collector,
-        counselor,
-        deputy,
-        factory,
-        isGitIgnored,
-        streamer,
-        workspaces,
-        options,
-    });
-    const reAnalyze = await analyze({
-        analyzedFiles,
-        counselor,
-        chief,
-        collector,
-        deputy,
-        entryPaths,
-        factory,
-        fixer,
-        graph,
-        streamer,
-        unreferencedFiles,
-        options,
-    });
-    if (options.isWatch) {
-        const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
-        const onUpdate = options.isWatch
-            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
-            : () => { };
-        const watchHandler = await getWatchHandler(options, {
-            analyzedFiles,
-            analyzeSourceFile,
-            chief,
-            collector,
-            analyze: reAnalyze,
-            factory,
-            graph,
-            isIgnored,
-            onUpdate,
-            unreferencedFiles,
-        });
-        watch('.', { recursive: true }, watchHandler);
-    }
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    if (options.isFix) {
-        const touchedFiles = await fixer.fixIssues(issues);
-        if (options.isFormat) {
-            const report = await formatly(Array.from(touchedFiles));
-            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
-                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
-            }
-            else {
-                debugLogObject('*', 'Formatting files failed', report);
-            }
-        }
-    }
-    if (!options.isWatch)
-        streamer.clear();
-    return {
-        issues,
-        counters,
-        tagHints,
-        configurationHints,
-        includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
-    };
-};
+import { run } from './run.js';
+export const main = async (options) => (await run(options)).results;

package/dist/plugins/angular/index.js

@@ -36,8 +36,8 @@ const resolveConfig = async (config, options) => {
                 }
                 return opts.isProduction ? toProductionEntry(normalizedPath) : toEntry(normalizedPath);
             };
-            for (const [configName, entriesByOption] of entriesByOptionByConfig.entries()) {
-                for (const [option, entries] of entriesByOption.entries()) {
+            for (const [configName, entriesByOption] of entriesByOptionByConfig) {
+                for (const [option, entries] of entriesByOption) {
                     for (const entry of entries) {
                         inputs.add(toInput(entry, {
                             isProduction: isBuildTarget && configName === PRODUCTION_CONFIG_NAME,
@@ -46,7 +46,7 @@ const resolveConfig = async (config, options) => {
                     }
                 }
             }
-            for (const [option, entries] of defaultEntriesByOption.entries()) {
+            for (const [option, entries] of defaultEntriesByOption) {
                 for (const entry of entries) {
                     inputs.add(toInput(entry, {
                         isProduction: isBuildTarget && !productionEntriesByOption.get(option)?.length,

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/next/index.js

@@ -1,6 +1,6 @@
-import { toProductionEntry } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getPageExtensions } from './resolveFromAST.js';
+import { getMdxPlugins, getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -26,7 +26,8 @@ const resolveFromAST = sourceFile => {
     const pageExtensions = getPageExtensions(sourceFile);
     const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
     const patterns = getEntryFilePatterns(extensions);
-    return patterns.map(id => toProductionEntry(id));
+    const mdxPlugins = getMdxPlugins(sourceFile);
+    return [...patterns.map(id => toProductionEntry(id)), ...Array.from(mdxPlugins).map(id => toDependency(id))];
 };
 const plugin = {
     title,

package/dist/plugins/next/resolveFromAST.d.ts

@@ -1,2 +1,3 @@
 import ts from 'typescript';
 export declare const getPageExtensions: (sourceFile: ts.SourceFile) => string[];
+export declare const getMdxPlugins: (sourceFile: ts.SourceFile) => Set<string>;

package/dist/plugins/next/resolveFromAST.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { getPropertyValues } from '../../typescript/ast-helpers.js';
+import { getDefaultImportName, getImportMap, getPropertyValues, stripQuotes } from '../../typescript/ast-helpers.js';
 export const getPageExtensions = (sourceFile) => {
     const pageExtensions = new Set();
     function visit(node) {
@@ -13,3 +13,44 @@ export const getPageExtensions = (sourceFile) => {
     visit(sourceFile);
     return Array.from(pageExtensions);
 };
+const isNamedProp = (prop, name) => ts.isPropertyAssignment(prop) && prop.name.getText() === name;
+export const getMdxPlugins = (sourceFile) => {
+    const plugins = new Set();
+    const importMap = getImportMap(sourceFile);
+    const mdxImportName = getDefaultImportName(importMap, '@next/mdx');
+    if (!mdxImportName)
+        return plugins;
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === mdxImportName) {
+            if (node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+                const options = node.arguments[0]?.properties.find(prop => isNamedProp(prop, 'options'));
+                if (options && ts.isPropertyAssignment(options)) {
+                    if (ts.isObjectLiteralExpression(options.initializer)) {
+                        for (const pluginType of ['remarkPlugins', 'rehypePlugins', 'recmaPlugins']) {
+                            const props = options.initializer.properties.find(prop => isNamedProp(prop, pluginType));
+                            if (props && ts.isPropertyAssignment(props)) {
+                                if (ts.isArrayLiteralExpression(props.initializer)) {
+                                    for (const element of props.initializer.elements) {
+                                        if (ts.isStringLiteral(element)) {
+                                            plugins.add(stripQuotes(element.text));
+                                        }
+                                        else if (ts.isArrayLiteralExpression(element) && element.elements.length > 0) {
+                                            const firstElement = element.elements[0];
+                                            if (ts.isStringLiteral(firstElement)) {
+                                                plugins.add(stripQuotes(firstElement.text));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return ts.forEachChild(node, visit) ?? false;
+    }
+    visit(sourceFile);
+    return plugins;
+};

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/helpers.js

@@ -4,7 +4,7 @@ export const getReactBabelPlugins = (sourceFile) => {
     const babelPlugins = [];
     const importMap = getImportMap(sourceFile);
     const reactPluginNames = new Set();
-    for (const [importName, importPath] of importMap.entries()) {
+    for (const [importName, importPath] of importMap) {
         if (importPath.includes('@vitejs/plugin-react')) {
             reactPluginNames.add(importName);
         }

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;