knip 5.71.0 → 5.73.0

package/dist/ConfigurationChief.d.ts

@@ -327,6 +327,16 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'next-intl'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        'next-mdx'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -527,6 +537,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;
@@ -723,6 +738,8 @@ export declare class ConfigurationChief {
         nest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         netlify?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "next-intl"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "next-mdx"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "node-modules-inspector"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         nodemon?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "npm-package-json-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -761,6 +778,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

@@ -279,6 +279,16 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'next-intl'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
+    'next-mdx'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     node?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -479,6 +489,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;
@@ -875,6 +890,16 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'next-intl'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        'next-mdx'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         node?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1075,6 +1100,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/constants.js

@@ -34,6 +34,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'chmod',
     'chown',
     'cksum',
+    'clear',
     'cmd',
     'comm',
     'command',

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

@@ -54,6 +54,8 @@ export declare const Plugins: {
     nest: import("../types/config.js").Plugin;
     netlify: import("../types/config.js").Plugin;
     next: import("../types/config.js").Plugin;
+    'next-intl': import("../types/config.js").Plugin;
+    'next-mdx': import("../types/config.js").Plugin;
     node: import("../types/config.js").Plugin;
     'node-modules-inspector': import("../types/config.js").Plugin;
     nodemon: import("../types/config.js").Plugin;
@@ -94,6 +96,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

@@ -53,6 +53,8 @@ import { default as nanoStaged } from './nano-staged/index.js';
 import { default as nest } from './nest/index.js';
 import { default as netlify } from './netlify/index.js';
 import { default as next } from './next/index.js';
+import { default as nextIntl } from './next-intl/index.js';
+import { default as nextMdx } from './next-mdx/index.js';
 import { default as node } from './node/index.js';
 import { default as nodeModulesInspector } from './node-modules-inspector/index.js';
 import { default as nodemon } from './nodemon/index.js';
@@ -93,6 +95,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';
@@ -173,6 +176,8 @@ export const Plugins = {
     nest,
     netlify,
     next,
+    'next-intl': nextIntl,
+    'next-mdx': nextMdx,
     node,
     'node-modules-inspector': nodeModulesInspector,
     nodemon,
@@ -213,6 +218,7 @@ export const Plugins = {
     stylelint,
     svelte,
     svgo,
+    svgr,
     syncpack,
     tailwind,
     taskfile,

package/dist/plugins/next/index.js

@@ -1,6 +1,6 @@
-import { toDependency, toProductionEntry } from '../../util/input.js';
+import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getMdxPlugins, getPageExtensions } from './resolveFromAST.js';
+import { getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -12,7 +12,6 @@ const productionEntryFilePatterns = [
     'app/**/sitemap.{js,ts}',
     'app/**/{icon,apple-icon}.{js,jsx,ts,tsx}',
     'app/**/{opengraph,twitter}-image.{js,jsx,ts,tsx}',
-    'mdx-components.{js,jsx,ts,tsx}',
 ];
 const getEntryFilePatterns = (pageExtensions = defaultPageExtensions) => {
     const patterns = [...productionEntryFilePatterns];
@@ -26,8 +25,7 @@ const resolveFromAST = sourceFile => {
     const pageExtensions = getPageExtensions(sourceFile);
     const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
     const patterns = getEntryFilePatterns(extensions);
-    const mdxPlugins = getMdxPlugins(sourceFile);
-    return [...patterns.map(id => toProductionEntry(id)), ...Array.from(mdxPlugins).map(id => toDependency(id))];
+    return patterns.map(id => toProductionEntry(id));
 };
 const plugin = {
     title,

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

@@ -1,3 +1,2 @@
 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 { getDefaultImportName, getImportMap, getPropertyValues, stripQuotes } from '../../typescript/ast-helpers.js';
+import { getPropertyValues } from '../../typescript/ast-helpers.js';
 export const getPageExtensions = (sourceFile) => {
     const pageExtensions = new Set();
     function visit(node) {
@@ -13,44 +13,3 @@ 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/next-intl/index.d.ts

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