knip 5.70.1 → 5.71.0

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

@@ -0,0 +1,51 @@
+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 rootNode = {
+        filePath,
+        identifier,
+        hasRef: false,
+        isEntry: entryPaths.has(filePath),
+        children: [],
+    };
+    const nodeMap = new Map();
+    nodeMap.set(`${filePath}:${identifier}`, rootNode);
+    walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, isReExport) => {
+        const key = `${importingFile}:${id}`;
+        const childNode = nodeMap.get(key) ?? {
+            filePath: importingFile,
+            identifier: id,
+            hasRef: !isReExport && Boolean(graph.get(importingFile)?.traceRefs?.has(id)),
+            isEntry,
+            children: [],
+        };
+        nodeMap.set(key, childNode);
+        const parentKey = `${sourceFile}:${sourceId}`;
+        const parentNode = nodeMap.get(parentKey) ?? rootNode;
+        parentNode.children.push(childNode);
+        return CONTINUE;
+    }, entryPaths);
+    return rootNode;
+};

package/dist/graph-explorer/operations/has-strictly-ns-references.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMaps, ModuleGraph } from '../../types/module-graph.js';
+export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, identifier: string) => [boolean, string?];

package/dist/graph-explorer/operations/has-strictly-ns-references.js

@@ -0,0 +1,98 @@
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
+export const hasStrictlyNsReferences = (graph, importsForExport, identifier) => {
+    if (!importsForExport)
+        return [false];
+    let foundNamespace;
+    const aliasByIdentifier = new Map();
+    const namespaceReExports = new Map();
+    const namespaceEdges = [];
+    const directById = new Map();
+    forEachPassThroughReExport(importsForExport, (id, sources) => {
+        directById.set(id, sources);
+    });
+    forEachAliasReExport(importsForExport, (id, alias, sources) => {
+        let arr = aliasByIdentifier.get(id);
+        if (!arr) {
+            arr = [];
+            aliasByIdentifier.set(id, arr);
+        }
+        arr.push({ alias, sources });
+    });
+    forEachNamespaceReExport(importsForExport, (namespace, sources) => {
+        namespaceEdges.push({ namespace, sources });
+        let arr = namespaceReExports.get(namespace);
+        if (!arr) {
+            arr = [];
+            namespaceReExports.set(namespace, arr);
+        }
+        arr.push(sources);
+    });
+    const starSources = getStarReExportSources(importsForExport);
+    const followReExports = (sources, nextId, propagateNamespace = true) => {
+        for (const filePath of sources) {
+            const file = graph.get(filePath);
+            if (!file?.imported)
+                continue;
+            const result = hasStrictlyNsReferences(graph, file.imported, nextId);
+            if (result[0] === false)
+                return result;
+            if (propagateNamespace && result[1])
+                foundNamespace = result[1];
+        }
+        return undefined;
+    };
+    for (const ns of importsForExport.importedNs.keys()) {
+        const hasNsRef = importsForExport.refs.has(ns);
+        if (!hasNsRef)
+            return [false, ns];
+        for (const ref of importsForExport.refs) {
+            if (ref.startsWith(`${ns}.`))
+                return [false, ns];
+        }
+        const nsReExports = namespaceReExports.get(ns);
+        if (nsReExports) {
+            for (const sources of nsReExports) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        const nsAliases = aliasByIdentifier.get(ns);
+        if (nsAliases) {
+            for (const { sources } of nsAliases) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        foundNamespace = ns;
+    }
+    const directSources = directById.get(identifier);
+    if (directSources) {
+        const result = followReExports(directSources, identifier, true);
+        if (result)
+            return result;
+    }
+    if (starSources) {
+        const result = followReExports(starSources, identifier, true);
+        if (result)
+            return result;
+    }
+    const [id, ...rest] = identifier.split('.');
+    const aliasEntries = aliasByIdentifier.get(id);
+    if (aliasEntries) {
+        for (const { alias, sources } of aliasEntries) {
+            const result = followReExports(sources, [alias, ...rest].join('.'), true);
+            if (result)
+                return result;
+        }
+    }
+    for (const { namespace: ns, sources } of namespaceEdges) {
+        const result = followReExports(sources, `${ns}.${identifier}`, true);
+        if (result)
+            return result;
+    }
+    if (foundNamespace)
+        return [true, foundNamespace];
+    return [false];
+};

package/dist/graph-explorer/operations/is-referenced.d.ts

@@ -0,0 +1,4 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+export declare const isReferenced: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, id: Identifier, options: {
+    includeEntryExports: boolean;
+}) => [boolean, string | undefined];

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 (isEntryFile && !options.includeEntryExports)
+            return [false, reExportingEntryFile];
+        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 directSources = getPassThroughReExportSources(file, identifier);
+        const starSources = getStarReExportSources(file);
+        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];
+            }
+        }
+        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];
+            }
+        }
+        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,4 @@
+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;
+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,28 @@
+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;
+    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,4 @@
+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 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,119 @@
+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}`;
+    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, false) === 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, false) === 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) {
+                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, true) === 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, true) === 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, true) === 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, true) === 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/astro/index.js

@@ -6,7 +6,6 @@ const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 export const config = ['astro.config.{js,cjs,mjs,ts,mts}'];
 const entry = ['src/content/config.ts', 'src/content.config.ts'];
-const project = ['src/**/*'];
 const production = [
     'src/pages/**/*.{astro,mdx,js,ts}',
     '!src/pages/**/_*',
@@ -42,6 +41,5 @@ const plugin = {
     production,
     resolveFromAST,
     resolve,
-    project,
 };
 export default plugin;

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;
+};