knip 6.34.0 → 6.35.1

package/dist/compilers/index.js

@@ -3,41 +3,35 @@ import MDX from './mdx.js';
 import SCSS from './scss.js';
 import STYLUS from './stylus.js';
 import TSRX from './tsrx.js';
-const isAsyncCompiler = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
 export const normalizeCompilerExtension = (ext) => ext.replace(/^\.*/, '.');
-export const partitionCompilers = (rawLocalConfig) => {
-    const syncCompilers = {};
-    const asyncCompilers = {};
+export const normalizeCompilers = (rawLocalConfig) => {
+    const compilers = new Map();
     for (const extension in rawLocalConfig.compilers) {
         const ext = normalizeCompilerExtension(extension);
         const compilerFn = rawLocalConfig.compilers[extension];
-        if (typeof compilerFn === 'function') {
-            if (!rawLocalConfig.asyncCompilers?.[ext] && isAsyncCompiler(compilerFn)) {
-                asyncCompilers[ext] = compilerFn;
-            }
-            else {
-                syncCompilers[ext] = compilerFn;
-            }
-        }
-        else if (compilerFn === true) {
-            syncCompilers[ext] = true;
-        }
+        if (typeof compilerFn === 'function' || compilerFn === true)
+            compilers.set(ext, compilerFn);
     }
     for (const extension in rawLocalConfig.asyncCompilers) {
         const ext = normalizeCompilerExtension(extension);
-        asyncCompilers[ext] = rawLocalConfig.asyncCompilers[extension];
+        compilers.set(ext, rawLocalConfig.asyncCompilers[extension]);
     }
-    return { ...rawLocalConfig, syncCompilers, asyncCompilers };
+    return compilers;
 };
-const compilers = [
+const builtInCompilers = [
     { extensions: ['.mdx'], ...MDX },
     { extensions: ['.sass', '.scss'], ...SCSS },
     { extensions: ['.less'], ...LESS },
     { extensions: ['.styl', '.stylus'], ...STYLUS },
     { extensions: ['.tsrx'], ...TSRX },
 ];
-export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies, onReferencedDependency) => {
-    for (const { extensions, dependencies: compilerDependencies, compiler } of compilers) {
+export const getIncludedCompilers = (rawCompilers, dependencies, onReferencedDependency) => {
+    const compilers = new Map();
+    for (const [extension, compiler] of rawCompilers) {
+        if (typeof compiler === 'function')
+            compilers.set(extension, compiler);
+    }
+    for (const { extensions, dependencies: compilerDependencies, compiler } of builtInCompilers) {
         let hasCompilerDependency = false;
         for (const dependency of compilerDependencies) {
             if (dependencies.has(dependency)) {
@@ -49,15 +43,11 @@ export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies
             }
         }
         for (const extension of extensions) {
-            const existingCompiler = syncCompilers.get(extension);
+            const existingCompiler = rawCompilers.get(extension);
             if (existingCompiler === true || (existingCompiler === undefined && hasCompilerDependency)) {
-                syncCompilers.set(extension, compiler);
+                compilers.set(extension, compiler);
             }
         }
     }
-    return [syncCompilers, asyncCompilers];
+    return compilers;
 };
-export const getCompilerExtensions = (compilers) => [
-    ...compilers[0].keys(),
-    ...compilers[1].keys(),
-];

package/dist/compilers/types.d.ts

@@ -1,9 +1,8 @@
 type FileExtension = string;
 export type CompilerSync = (source: string, path: string) => string;
-export type CompilerAsync = (source: string, path: string) => Promise<string>;
-export type RawSyncCompilers = Map<FileExtension, CompilerSync | true>;
-export type SyncCompilers = Map<FileExtension, CompilerSync>;
-export type AsyncCompilers = Map<FileExtension, CompilerAsync>;
-export type Compilers = [SyncCompilers, AsyncCompilers];
+export type CompilerResult = string | PromiseLike<string>;
+export type Compiler = (source: string, path: string) => CompilerResult;
+export type RawCompilers = Map<FileExtension, Compiler | true>;
+export type Compilers = Map<FileExtension, Compiler>;
 export type HasDependency = (pkgName: string) => boolean;
 export {};

package/dist/graph/analyze.js

@@ -55,6 +55,45 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
         }
         return false;
     };
+    const getMemberIssues = (exportedItem, filePath, identifier, workspace, importsForExport) => {
+        const isEnumMembers = options.includedIssueTypes.enumMembers && exportedItem.type === 'enum';
+        const isNsMembers = options.includedIssueTypes.namespaceMembers && exportedItem.members.length > 0 && exportedItem.type !== 'enum';
+        if (!isEnumMembers && !isNsMembers)
+            return;
+        if (exportedItem.members.length === 0)
+            return;
+        if (explorer.isEnumerated(filePath, identifier))
+            return;
+        if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
+            return;
+        if (isEnumMembers && hasStrictlyEnumReferences(importsForExport, identifier))
+            return;
+        const issueType = isEnumMembers ? 'enumMembers' : 'namespaceMembers';
+        const unusedMembers = [];
+        const ignoredMemberIds = [];
+        for (const member of exportedItem.members) {
+            if (findMatch(workspace.ignoreMembers, member.identifier))
+                continue;
+            if (shouldIgnore(member.jsDocTags))
+                continue;
+            if (member.hasRefsInFile)
+                continue;
+            const id = `${identifier}.${member.identifier}`;
+            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+                traverseEntries: true,
+                treatStarAtEntryAsReferenced: true,
+            });
+            const isMemberIgnored = shouldIgnoreTags(member.jsDocTags);
+            if (!isMemberReferenced) {
+                if (!isMemberIgnored)
+                    unusedMembers.push(member);
+            }
+            else if (isMemberIgnored) {
+                ignoredMemberIds.push(id);
+            }
+        }
+        return { issueType, unusedMembers, ignoredMemberIds };
+    };
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
@@ -79,17 +118,22 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
                                 traverseEntries: isIncludeEntryExports,
                             });
-                            if (isIgnored &&
-                                (isReferenced ||
-                                    isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports, ignoreExportsUsedInFile))) {
-                                for (const tagName of exportedItem.jsDocTags) {
-                                    if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
-                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                            if (isIgnored) {
+                                if (isReferenced ||
+                                    isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports, ignoreExportsUsedInFile)) {
+                                    const memberIssues = isReferenced
+                                        ? getMemberIssues(exportedItem, filePath, identifier, workspace, importsForExport)
+                                        : undefined;
+                                    if (!memberIssues || memberIssues.unusedMembers.length === 0) {
+                                        for (const tagName of exportedItem.jsDocTags) {
+                                            if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
+                                                collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                            }
+                                        }
                                     }
                                 }
-                            }
-                            if (isIgnored)
                                 continue;
+                            }
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
                                     continue;
@@ -101,51 +145,25 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 }
                             }
                             if (isReferenced) {
-                                const isEnumMembers = options.includedIssueTypes.enumMembers && exportedItem.type === 'enum';
-                                const isNsMembers = options.includedIssueTypes.namespaceMembers &&
-                                    exportedItem.members.length > 0 &&
-                                    exportedItem.type !== 'enum';
-                                if ((isEnumMembers || isNsMembers) && exportedItem.members.length > 0) {
-                                    if (explorer.isEnumerated(filePath, identifier))
-                                        continue;
-                                    if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
-                                        continue;
-                                    if (isEnumMembers && hasStrictlyEnumReferences(importsForExport, identifier))
-                                        continue;
-                                    const issueType = isEnumMembers ? 'enumMembers' : 'namespaceMembers';
-                                    for (const member of exportedItem.members) {
-                                        if (findMatch(workspace.ignoreMembers, member.identifier))
-                                            continue;
-                                        if (shouldIgnore(member.jsDocTags))
-                                            continue;
-                                        if (!member.hasRefsInFile) {
-                                            const id = `${identifier}.${member.identifier}`;
-                                            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
-                                                traverseEntries: true,
-                                                treatStarAtEntryAsReferenced: true,
-                                            });
-                                            const isIgnored = shouldIgnoreTags(member.jsDocTags);
-                                            if (!isMemberReferenced) {
-                                                if (isIgnored)
-                                                    continue;
-                                                collector.addIssue({
-                                                    type: issueType,
-                                                    filePath,
-                                                    workspace: workspace.name,
-                                                    symbol: member.identifier,
-                                                    parentSymbol: identifier,
-                                                    pos: member.pos,
-                                                    line: member.line,
-                                                    col: member.col,
-                                                    fixes: member.fix ? [member.fix] : [],
-                                                });
-                                            }
-                                            else if (isIgnored) {
-                                                for (const tagName of exportedItem.jsDocTags) {
-                                                    if (options.tags[1].includes(tagName)) {
-                                                        collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
-                                                    }
-                                                }
+                                const memberIssues = getMemberIssues(exportedItem, filePath, identifier, workspace, importsForExport);
+                                if (memberIssues) {
+                                    for (const member of memberIssues.unusedMembers) {
+                                        collector.addIssue({
+                                            type: memberIssues.issueType,
+                                            filePath,
+                                            workspace: workspace.name,
+                                            symbol: member.identifier,
+                                            parentSymbol: identifier,
+                                            pos: member.pos,
+                                            line: member.line,
+                                            col: member.col,
+                                            fixes: member.fix ? [member.fix] : [],
+                                        });
+                                    }
+                                    for (const id of memberIssues.ignoredMemberIds) {
+                                        for (const tagName of exportedItem.jsDocTags) {
+                                            if (options.tags[1].includes(tagName)) {
+                                                collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
                                             }
                                         }
                                     }

package/dist/graph/build.d.ts

@@ -1,11 +1,11 @@
 import type { ScriptParserContext } from '../binaries/create-script-parser-context.ts';
 import type { CatalogCounselor } from '../CatalogCounselor.ts';
-import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
+import { type ConfigurationChief, type Workspace } from '../ConfigurationChief.ts';
 import type { ConsoleStreamer } from '../ConsoleStreamer.ts';
 import type { DependencyDeputy } from '../DependencyDeputy.ts';
 import type { IssueCollector } from '../IssueCollector.ts';
 import type { ProjectPrincipal } from '../ProjectPrincipal.ts';
-import type { FileNode, ModuleGraph } from '../types/module-graph.ts';
+import type { ModuleGraph } from '../types/module-graph.ts';
 import type { MainOptions } from '../util/create-options.ts';
 interface BuildOptions {
     chief: ConfigurationChief;
@@ -24,7 +24,7 @@ export declare function build({ chief, collector, counselor, deputy, principal,
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;
     unreferencedFiles: Set<string>;
-    analyzeSourceFile: (filePath: string, pp: ProjectPrincipal, parseResult?: import('oxc-parser').ParseResult, sourceText?: string, cachedFile?: FileNode) => void;
+    analyzeSourceFile: (filePath: string) => Promise<void>;
     enabledPluginsStore: Map<string, string[]>;
 }>;
 export {};

package/dist/graph/build.js

@@ -1,6 +1,7 @@
 import { _getInputsFromScripts } from '../binaries/index.js';
-import { getCompilerExtensions, getIncludedCompilers, normalizeCompilerExtension } from '../compilers/index.js';
-import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS } from '../constants.js';
+import { isDefaultPattern } from '../ConfigurationChief.js';
+import { getIncludedCompilers, normalizeCompilerExtension } from '../compilers/index.js';
+import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, IS_DTS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { partition } from '../util/array.js';
 import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
@@ -9,7 +10,7 @@ import picomatch from 'picomatch';
 import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
-import { isAlias, isCatalog, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { isAlias, isCatalog, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toDeferResolveEntry, toDependency, toProductionEntry, } from '../util/input.js';
 import { isAmbientDeclarationFile } from '../typescript/ast-nodes.js';
 import { resolveImportGlobs } from '../typescript/glob-imports.js';
 import { createPublishedTypeDependencyAnalyzer } from '../typescript/get-published-type-dependencies.js';
@@ -18,7 +19,7 @@ import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
-import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '../util/path.js';
+import { dirname, extname, isAbsolute, isInNodeModules, isInternal, join, relative } from '../util/path.js';
 import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
@@ -54,6 +55,21 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     if (options.configFilePath) {
         principal.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
     }
+    const preprocessorInputs = new Map();
+    for (const specifier of options.preprocessorInputs) {
+        const containingFilePath = options.configFilePath ?? join(options.cwd, 'package.json');
+        const isLocal = isInternal(specifier);
+        const input = isLocal
+            ? toDeferResolveEntry(specifier, { containingFilePath })
+            : toDependency(specifier, { containingFilePath, optional: true });
+        const owner = isLocal ? chief.findWorkspaceByFilePath(specifier)?.name : undefined;
+        const name = owner ?? ROOT_WORKSPACE_NAME;
+        const inputs = preprocessorInputs.get(name);
+        if (inputs)
+            inputs.push(input);
+        else
+            preprocessorInputs.set(name, [input]);
+    }
     for (const workspace of workspaces) {
         const { name, dir, ancestors, config: baseConfig, manifestPath: filePath } = workspace;
         streamer.cast('Analyzing workspace', name);
@@ -72,32 +88,33 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             dependencies,
             rootManifest,
             handleInput: (input) => handleInput(input, workspace),
+            handleConfigLoadError: () => collector.addConfigLoadError(),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
             getManifest,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
-            readFile: (filePath) => principal.readFile(filePath),
+            readRawFile: (filePath) => principal.fileManager.readRawFile(filePath) ?? '',
             configFilesMap,
             options,
         });
         await worker.init();
-        const compilers = getIncludedCompilers(new Map(chief.config.syncCompilers), new Map(chief.config.asyncCompilers), dependencies, dep => deputy.addReferencedDependency(name, dep));
-        const registerCompiler = async ({ extension, compiler }) => {
+        const compilers = getIncludedCompilers(chief.config.compilers, dependencies, dep => deputy.addReferencedDependency(name, dep));
+        const registerCompiler = ({ extension, compiler }) => {
             const ext = normalizeCompilerExtension(extension);
-            if (compilers[0].has(ext))
+            if (compilers.has(ext))
                 return;
-            compilers[0].set(ext, compiler);
+            compilers.set(ext, compiler);
         };
         await worker.registerCompilers(registerCompiler);
         principal.addCompilers(name, compilers);
-        const extensions = getCompilerExtensions(compilers);
+        const extensions = [...compilers.keys()];
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
         worker.config = config;
         const pluginSourceMaps = await worker.resolveSourceMaps();
         augmentWorkspace(workspace, dir, isFile ? compilerOptions : undefined, [...pluginSourceMaps, ...sourceMapPairs]);
-        const inputs = new Set();
+        const inputs = new Set(preprocessorInputs.get(name));
         if (definitionPaths.length > 0) {
             debugLogArray(name, 'Definition paths', definitionPaths);
             for (const id of definitionPaths)
@@ -268,11 +285,15 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             }
         }
         if (!options.isProduction) {
-            const hints = worker.getConfigurationHints('entry', userEntryPatterns, userEntryPaths, principal.entryPaths);
+            const includedPaths = config.isIncludeEntryExports
+                ? new Set([...principal.entryPaths].filter(filePath => !principal.skipExportsAnalysis.has(filePath)))
+                : principal.entryPaths;
+            const hints = worker.getConfigurationHints('entry', userEntryPatterns, userEntryPaths, includedPaths);
             for (const hint of hints)
                 collector.addConfigurationHint(hint);
         }
-        principal.addEntryPaths(userEntryPaths);
+        const hasExplicitEntries = config.entry.some(pattern => !isDefaultPattern('entry', pattern));
+        principal.addEntryPaths(userEntryPaths, hasExplicitEntries ? { skipExportsAnalysis: false } : undefined);
         if (options.isUseTscFiles && isFile) {
             const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
             debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
@@ -330,13 +351,13 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         skipTypeOnly: options.isStrict,
         tags: options.tags,
     };
-    const analyzeSourceFile = (filePath, pp, parseResult, sourceText, cachedFile) => {
+    const analyzeSourceFile = (filePath, sourceText, parseResult, cachedFile) => {
         if (!options.isWatch && !options.isSession && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const file = pp.analyzeSourceFile(filePath, analyzeOpts, workspace.config.ignoreExportsUsedInFile, parseResult, sourceText, cachedFile);
+            const file = principal.analyzeSourceFile(filePath, sourceText, analyzeOpts, workspace.config.ignoreExportsUsedInFile, parseResult, cachedFile);
             const unresolvedImports = new Set();
             for (const unresolvedImport of file.imports.unresolved) {
                 const { specifier } = unresolvedImport;
@@ -368,12 +389,12 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             for (const filePath of file.imports.programFiles) {
                 const isIgnored = isGitIgnored(filePath);
                 if (!isIgnored)
-                    pp.addProgramPath(filePath);
+                    principal.addProgramPath(filePath);
             }
             for (const filePath of file.imports.entryFiles) {
                 const isIgnored = isGitIgnored(filePath);
                 if (!isIgnored)
-                    pp.addEntryPath(filePath, { skipExportsAnalysis: true });
+                    principal.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
             const wsDependencies = deputy.getDependencies(workspace.name);
             for (const _import of file.imports.imports) {
@@ -386,7 +407,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 if (isWorkspace || wsDependencies.has(packageName)) {
                     file.imports.external.add({ ..._import, specifier: packageName });
                     if (isWorkspace && !isGitIgnored(_import.filePath)) {
-                        pp.addProgramPath(_import.filePath);
+                        principal.addProgramPath(_import.filePath);
                     }
                 }
             }
@@ -413,14 +434,20 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     input.dir ??= dir;
                     const specifierFilePath = handleInput(input, workspace);
                     if (specifierFilePath)
-                        pp.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
+                        principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
             if (file.importGlobs.length > 0) {
-                const globbed = resolveImportGlobs(file.importGlobs, filePath, pp.resolveGlobPattern, workspace.dir);
-                for (const importedFilePath of globbed) {
+                const [analyzedImportGlobs, entryImportGlobs] = partition(file.importGlobs, glob => glob.analyzeExports);
+                const analyzed = resolveImportGlobs(analyzedImportGlobs, filePath, principal.resolveGlobPattern, workspace.dir);
+                for (const importedFilePath of analyzed) {
+                    if (!isGitIgnored(importedFilePath))
+                        principal.addProgramPath(importedFilePath);
+                }
+                const entries = resolveImportGlobs(entryImportGlobs, filePath, principal.resolveGlobPattern, workspace.dir);
+                for (const importedFilePath of entries) {
                     if (!isGitIgnored(importedFilePath))
-                        pp.addEntryPath(importedFilePath, { skipExportsAnalysis: true });
+                        principal.addEntryPath(importedFilePath, { skipExportsAnalysis: true });
                 }
             }
             file.imports.unresolved = unresolvedImports;
@@ -430,6 +457,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     file.imports.externalRefs.add(ref);
             const node = graph.get(filePath);
             if (node) {
+                node.skipExports = file.skipExports;
                 node.imports = file.imports;
                 node.exports = file.exports;
                 node.duplicates = file.duplicates;
@@ -446,13 +474,9 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
     };
     principal.init();
-    if (principal.asyncCompilers.size > 0) {
-        streamer.cast('Running async compilers');
-        await principal.runAsyncCompilers();
-    }
     streamer.cast('Analyzing source files');
-    principal.walkAndAnalyze((filePath, parseResult, sourceText, cachedFile) => {
-        analyzeSourceFile(filePath, principal, parseResult, sourceText, cachedFile);
+    await principal.walkAndAnalyze((filePath, parseResult, sourceText, cachedFile) => {
+        analyzeSourceFile(filePath, sourceText, parseResult, cachedFile);
         const node = graph.get(filePath);
         if (!node)
             return;
@@ -464,8 +488,13 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         return paths;
     });
     for (const filePath of principal.getUnreferencedFiles()) {
-        if (IS_DTS.test(filePath) && isAmbientDeclarationFile(filePath, principal.readFile(filePath)))
-            continue;
+        if (IS_DTS.test(filePath)) {
+            const loaded = principal.fileManager.loadSourceText(filePath);
+            const sourceText = typeof loaded === 'string' ? loaded : await loaded;
+            principal.fileManager.sourceTextCache.delete(filePath);
+            if (isAmbientDeclarationFile(filePath, sourceText))
+                continue;
+        }
         unreferencedFiles.add(filePath);
     }
     for (const filePath of principal.entryPaths)
@@ -485,7 +514,11 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         entryPaths,
         analyzedFiles,
         unreferencedFiles,
-        analyzeSourceFile,
+        analyzeSourceFile: async (filePath) => {
+            const loaded = principal.fileManager.loadSourceText(filePath);
+            const sourceText = typeof loaded === 'string' ? loaded : await loaded;
+            analyzeSourceFile(filePath, sourceText);
+        },
         enabledPluginsStore,
     };
 }

package/dist/index.d.ts

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

package/dist/plugins/_vue/auto-import.js

@@ -46,12 +46,21 @@ const readFile = (filePath) => {
     }
 };
 export const readAndParseFile = (filePath) => _parseFile(filePath, readFile(filePath));
-const collectIdentifiers = (source, fileName) => {
+const collectIdentifiers = (source, fileName, importedComponents) => {
     const identifiers = new Set();
     const visitor = new Visitor({
         Identifier(node) {
             identifiers.add(node.name);
         },
+        ImportDeclaration(node) {
+            if (importedComponents && node.source.value === '#components') {
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === 'ImportSpecifier') {
+                        importedComponents.add(specifier.imported.type === 'Identifier' ? specifier.imported.name : specifier.imported.value);
+                    }
+                }
+            }
+        },
     });
     visitor.visit(_parseFile(fileName, source).program);
     return identifiers;
@@ -225,6 +234,15 @@ const getSyntheticImports = (maps, identifiers, templateTags) => {
     }
     return syntheticImports;
 };
+const getImportedComponentImports = (maps, names) => {
+    const imports = [];
+    for (const importedName of names) {
+        const name = importedName.startsWith('Lazy') ? importedName.slice(4) : importedName;
+        for (const specifier of maps.componentMap.get(name) ?? [])
+            imports.push(`import '${specifier}';`);
+    }
+    return imports;
+};
 const compileVueSfc = (source, path, maps, root) => {
     if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
         return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
@@ -236,7 +254,8 @@ const compileVueSfc = (source, path, maps, root) => {
         scripts.push(descriptor.script.content);
     if (descriptor.scriptSetup?.content)
         scripts.push(descriptor.scriptSetup.content);
-    const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path);
+    const importedComponents = new Set();
+    const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path, importedComponents);
     const template = descriptor.template;
     const compiled = template && !template.ast && sfc.compileTemplate
         ? sfc.compileTemplate(template.content, path, descriptor.script?.lang === 'ts' ||
@@ -257,15 +276,20 @@ const compileVueSfc = (source, path, maps, root) => {
             identifiers.add(id);
     }
     scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
+    scripts.push(...getImportedComponentImports(maps, importedComponents));
     const styles = stylePreprocessorImports(source, path);
     if (styles)
         scripts.push(styles);
     return scripts.join(';\n');
 };
 const compileTs = (source, path, maps) => {
-    if (maps.importMap.size === 0 || path.endsWith('.d.ts') || path.endsWith('.config.ts'))
+    if ((maps.importMap.size === 0 && maps.componentMap.size === 0) ||
+        path.endsWith('.d.ts') ||
+        path.endsWith('.config.ts'))
         return source;
-    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path));
+    const importedComponents = new Set();
+    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path, importedComponents));
+    syntheticImports.push(...getImportedComponentImports(maps, importedComponents));
     return syntheticImports.length === 0 ? source : `${source}\n${syntheticImports.join('\n')}`;
 };
 const tagMatcher = /<([a-zA-Z][\w.-]*)/g;

package/dist/plugins/index.d.ts

@@ -68,6 +68,7 @@ export declare const Plugins: {
     mdx: import("../types/config.ts").Plugin;
     mdxlint: import("../types/config.ts").Plugin;
     metro: import("../types/config.ts").Plugin;
+    mise: import("../types/config.ts").Plugin;
     mocha: import("../types/config.ts").Plugin;
     moonrepo: import("../types/config.ts").Plugin;
     msw: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -62,6 +62,7 @@ import { default as marko } from './marko/index.js';
 import { default as mdx } from './mdx/index.js';
 import { default as mdxlint } from './mdxlint/index.js';
 import { default as metro } from './metro/index.js';
+import { default as mise } from './mise/index.js';
 import { default as mocha } from './mocha/index.js';
 import { default as moonrepo } from './moonrepo/index.js';
 import { default as msw } from './msw/index.js';
@@ -245,6 +246,7 @@ export const Plugins = {
     mdx,
     mdxlint,
     metro,
+    mise,
     mocha,
     moonrepo,
     msw,

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

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