knip 6.13.0 → 6.14.0

package/dist/CacheConsultant.d.ts

@@ -1,9 +1,9 @@
 import type { MainOptions } from './util/create-options.ts';
 import { type FileDescriptor } from './util/file-entry-cache.ts';
 export declare class CacheConsultant<T> {
-    private isEnabled;
     private cache;
+    getFileDescriptor: (filePath: string) => FileDescriptor<T>;
+    reconcile: () => void;
     constructor(name: string, options: MainOptions);
-    getFileDescriptor(filePath: string): FileDescriptor<T>;
-    reconcile(): void;
+    getCachedFile(filePath: string): T | undefined;
 }

package/dist/CacheConsultant.js

@@ -3,24 +3,21 @@ import { timerify } from './util/Performance.js';
 import { version } from './version.js';
 const dummyFileDescriptor = { key: '', changed: true, notFound: true };
 export class CacheConsultant {
-    isEnabled;
     cache;
+    getFileDescriptor = () => dummyFileDescriptor;
+    reconcile = () => { };
     constructor(name, options) {
-        this.isEnabled = options.isCache;
-        if (this.isEnabled) {
-            const cacheName = `${name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${options.isProduction ? '-prod' : ''}-${version}`;
-            this.cache = new FileEntryCache(cacheName, options.cacheLocation);
-            this.reconcile = timerify(this.cache.reconcile).bind(this.cache);
-            this.getFileDescriptor = timerify(this.cache.getFileDescriptor).bind(this.cache);
-        }
+        if (!options.isCache)
+            return;
+        const cacheName = `${name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${options.isProduction ? '-prod' : ''}-${version}`;
+        this.cache = new FileEntryCache(cacheName, options.cacheLocation);
+        this.getFileDescriptor = timerify(this.cache.getFileDescriptor.bind(this.cache));
+        this.reconcile = timerify(this.cache.reconcile.bind(this.cache));
     }
-    getFileDescriptor(filePath) {
-        if (this.isEnabled && this.cache)
-            return this.cache.getFileDescriptor(filePath);
-        return dummyFileDescriptor;
-    }
-    reconcile() {
-        if (this.isEnabled && this.cache)
-            this.cache.reconcile();
+    getCachedFile(filePath) {
+        if (!this.cache)
+            return undefined;
+        const fd = this.cache.getFileDescriptor(filePath);
+        return !fd.changed ? fd.meta?.data : undefined;
     }
 }

package/dist/ConfigurationChief.d.ts

@@ -35,6 +35,7 @@ export declare class ConfigurationChief {
     availableWorkspaceNames: string[];
     availableWorkspacePkgNames: Set<string>;
     availableWorkspaceDirs: string[];
+    private availableWorkspaceDirsWithSlash;
     workspaceGraph: WorkspaceGraph;
     private workspaceByFileCache;
     constructor(options: MainOptions);

package/dist/ConfigurationChief.js

@@ -8,6 +8,7 @@ import { _dirGlob, removeProductionSuffix } from './util/glob.js';
 import { graphSequencer } from './util/graph-sequencer.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { join, relative } from './util/path.js';
+import { timerify } from './util/Performance.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
@@ -63,6 +64,7 @@ export class ConfigurationChief {
     availableWorkspaceNames = [];
     availableWorkspacePkgNames = new Set();
     availableWorkspaceDirs = [];
+    availableWorkspaceDirsWithSlash = [];
     workspaceGraph = new Map();
     workspaceByFileCache = new Map();
     constructor(options) {
@@ -74,6 +76,7 @@ export class ConfigurationChief {
         this.workspaces = options.workspaces;
         this.rawConfig = options.parsedConfig;
         this.config = this.normalize(options.parsedConfig ?? {});
+        this.findWorkspaceByFilePath = timerify(this.findWorkspaceByFilePath.bind(this), 'findWorkspaceByFilePath');
     }
     getConfigurationHints() {
         const hints = [];
@@ -139,6 +142,7 @@ export class ConfigurationChief {
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
+        this.availableWorkspaceDirsWithSlash = this.availableWorkspaceDirs.map(dir => `${dir}/`);
         this.workspaceGraph = createWorkspaceGraph(this.cwd, this.availableWorkspaceNames, wsPkgNames, packages);
         this.selectedWorkspaces = this.getSelectedWorkspaces();
         this.workspaceFilePathFilter = createWorkspaceFilePathFilter(this.cwd, this.selectedWorkspaces, this.availableWorkspaceNames);
@@ -347,8 +351,13 @@ export class ConfigurationChief {
     findWorkspaceByFilePath(filePath) {
         if (this.workspaceByFileCache.has(filePath))
             return this.workspaceByFileCache.get(filePath);
-        const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(`${workspaceDir}/`));
-        const workspace = workspaceDir ? this.workspacesByDir.get(workspaceDir) : undefined;
+        let workspace;
+        for (let i = 0; i < this.availableWorkspaceDirsWithSlash.length; i++) {
+            if (filePath.startsWith(this.availableWorkspaceDirsWithSlash[i])) {
+                workspace = this.workspacesByDir.get(this.availableWorkspaceDirs[i]);
+                break;
+            }
+        }
         this.workspaceByFileCache.set(filePath, workspace);
         return workspace;
     }

package/dist/DependencyDeputy.d.ts

@@ -8,6 +8,7 @@ export declare class DependencyDeputy {
     isStrict: boolean;
     isReportDependencies: boolean;
     _manifests: WorkspaceManifests;
+    workspacePkgNames: Set<string>;
     referencedDependencies: Map<string, Set<string>>;
     referencedBinaries: Map<string, Set<string>>;
     hostDependencies: Map<string, HostDependencies>;
@@ -43,8 +44,10 @@ export declare class DependencyDeputy {
         unusedIgnoreBinaries: Set<string | RegExp>;
         unusedIgnoreUnresolved: Set<string | RegExp>;
     } | undefined;
+    setWorkspacePkgNames(pkgNames: Iterable<string>): void;
     getProductionDependencies(workspaceName: string): DependencyArray;
     getDevDependencies(workspaceName: string): DependencyArray;
+    private dependencyCache;
     getDependencies(workspaceName: string): DependencySet;
     setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
     getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;

package/dist/DependencyDeputy.js

@@ -10,6 +10,7 @@ export class DependencyDeputy {
     isStrict;
     isReportDependencies;
     _manifests = new Map();
+    workspacePkgNames = new Set();
     referencedDependencies;
     referencedBinaries;
     hostDependencies;
@@ -39,11 +40,7 @@ export class DependencyDeputy {
         const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        const packageNames = [
-            ...dependencies,
-            ...(this.isStrict ? peerDependencies : []),
-            ...(this.isProduction ? [] : devDependencies),
-        ];
+        const packageNames = [...dependencies, ...peerDependencies, ...(this.isProduction ? [] : devDependencies)];
         if (this.isReportDependencies) {
             const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
                 packageNames,
@@ -79,6 +76,9 @@ export class DependencyDeputy {
     getWorkspaceManifest(workspaceName) {
         return this._manifests.get(workspaceName);
     }
+    setWorkspacePkgNames(pkgNames) {
+        this.workspacePkgNames = new Set(pkgNames);
+    }
     getProductionDependencies(workspaceName) {
         const manifest = this._manifests.get(workspaceName);
         if (!manifest)
@@ -90,11 +90,15 @@ export class DependencyDeputy {
     getDevDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.devDependencies ?? [];
     }
+    dependencyCache = new Map();
     getDependencies(workspaceName) {
+        let deps = this.dependencyCache.get(workspaceName);
+        if (deps)
+            return deps;
         const manifest = this._manifests.get(workspaceName);
-        if (!manifest)
-            return new Set();
-        return new Set([...manifest.dependencies, ...manifest.devDependencies]);
+        deps = manifest ? new Set([...manifest.dependencies, ...manifest.devDependencies]) : new Set();
+        this.dependencyCache.set(workspaceName, deps);
+        return deps;
     }
     setInstalledBinaries(workspaceName, installedBinaries) {
         this.installedBinaries.set(workspaceName, installedBinaries);
@@ -153,6 +157,22 @@ export class DependencyDeputy {
             return true;
         if (this._manifests.get(workspace.name)?.engines[packageName])
             return true;
+        if (!this.isStrict && this.workspacePkgNames.has(packageName)) {
+            this.addReferencedDependency(workspace.name, packageName);
+            return true;
+        }
+        if (!this.isStrict) {
+            for (const name of workspaceNames) {
+                const hosts = this.getHostDependenciesFor(name, packageName);
+                if (hosts.length === 0)
+                    continue;
+                const m = this._manifests.get(name);
+                if (m && hosts.some(h => m.allDependencies.has(h.name))) {
+                    this.addReferencedDependency(name, packageName);
+                    return true;
+                }
+            }
+        }
         this.addReferencedDependency(workspace.name, packageName);
         return false;
     }

package/dist/ProjectPrincipal.d.ts

@@ -27,6 +27,7 @@ export declare class ProjectPrincipal {
     private resolveModule;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
+    private onPathAdded;
     constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string): void;

package/dist/ProjectPrincipal.js

@@ -1,5 +1,5 @@
 import { extractSpecifiers } from './typescript/follow-imports.js';
-import { parseFile } from './typescript/ast-nodes.js';
+import { _parseFile } from './typescript/ast-nodes.js';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS } from './constants.js';
@@ -36,6 +36,7 @@ export class ProjectPrincipal {
     resolveModule = () => undefined;
     resolvedFiles = new Set();
     deletedFiles = new Set();
+    onPathAdded;
     constructor(options, toSourceFilePath, findWorkspaceManifestImports) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
@@ -44,6 +45,7 @@ export class ProjectPrincipal {
         this.fileManager = new SourceFileManager({
             compilers: [this.syncCompilers, this.asyncCompilers],
         });
+        this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
     addCompilers(compilers) {
         for (const [ext, compiler] of compilers[0]) {
@@ -100,6 +102,7 @@ export class ProjectPrincipal {
             this.projectPaths.add(filePath);
             if (options?.skipExportsAnalysis)
                 this.skipExportsAnalysis.add(filePath);
+            this.onPathAdded?.(filePath);
         }
     }
     addEntryPaths(filePaths, options) {
@@ -109,6 +112,7 @@ export class ProjectPrincipal {
     addProgramPath(filePath) {
         if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
             this.programPaths.add(filePath);
+            this.onPathAdded?.(filePath);
         }
     }
     addProjectPath(filePath) {
@@ -134,61 +138,48 @@ export class ProjectPrincipal {
     walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();
         const visited = new Set([...this.entryPaths, ...this.programPaths]);
-        let lastEntrySize = this.entryPaths.size;
-        let lastProgramSize = this.programPaths.size;
-        const rescanFrontier = () => {
-            if (this.entryPaths.size > lastEntrySize || this.programPaths.size > lastProgramSize) {
-                for (const p of this.entryPaths)
-                    visited.add(p);
-                for (const p of this.programPaths)
-                    visited.add(p);
-                lastEntrySize = this.entryPaths.size;
-                lastProgramSize = this.programPaths.size;
-            }
-        };
-        for (const filePath of visited) {
-            const isProjectPath = this.projectPaths.has(filePath);
-            let cachedFile;
-            if (isProjectPath) {
-                const fd = this.cache.getFileDescriptor(filePath);
-                if (!fd.changed && fd.meta?.data)
-                    cachedFile = fd.meta.data;
-            }
-            if (cachedFile) {
-                const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
-                if (internalPaths)
-                    for (const p of internalPaths)
-                        visited.add(p);
-                rescanFrontier();
-                continue;
-            }
-            const sourceText = this.fileManager.readFile(filePath);
-            if (!sourceText) {
-                if (isProjectPath)
-                    analyzeFile(filePath, undefined, '');
-                continue;
-            }
-            try {
-                const result = parseFile(filePath, sourceText);
-                this.fileManager.sourceTextCache.delete(filePath);
-                if (isProjectPath) {
-                    const internalPaths = analyzeFile(filePath, result, sourceText);
+        this.onPathAdded = p => visited.add(p);
+        try {
+            for (const filePath of visited) {
+                const isProjectPath = this.projectPaths.has(filePath);
+                const cachedFile = isProjectPath ? this.cache.getCachedFile(filePath) : undefined;
+                if (cachedFile) {
+                    const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
                     if (internalPaths)
                         for (const p of internalPaths)
                             visited.add(p);
+                    continue;
+                }
+                const sourceText = this.fileManager.readFile(filePath);
+                if (!sourceText) {
+                    if (isProjectPath)
+                        analyzeFile(filePath, undefined, '');
+                    continue;
                 }
-                else {
-                    for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
-                        const resolved = this.resolveSpecifier(specifier, filePath);
-                        if (resolved && !isInNodeModules(resolved))
-                            visited.add(resolved);
+                try {
+                    const result = _parseFile(filePath, sourceText);
+                    this.fileManager.sourceTextCache.delete(filePath);
+                    if (isProjectPath) {
+                        const internalPaths = analyzeFile(filePath, result, sourceText);
+                        if (internalPaths)
+                            for (const p of internalPaths)
+                                visited.add(p);
+                    }
+                    else {
+                        for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
+                            const resolved = this.resolveSpecifier(specifier, filePath);
+                            if (resolved && !isInNodeModules(resolved))
+                                visited.add(resolved);
+                        }
                     }
                 }
-                rescanFrontier();
-            }
-            catch {
+                catch {
+                }
             }
         }
+        finally {
+            this.onPathAdded = undefined;
+        }
         this.resolvedFiles = visited;
     }
     getUsedResolvedFiles() {
@@ -199,7 +190,7 @@ export class ProjectPrincipal {
             if (!sourceText)
                 continue;
             try {
-                const result = parseFile(filePath, sourceText);
+                const result = _parseFile(filePath, sourceText);
                 for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
                     const resolved = this.resolveSpecifier(specifier, filePath);
                     if (resolved && !isInNodeModules(resolved))
@@ -221,9 +212,9 @@ export class ProjectPrincipal {
     analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText, cachedFile) {
         if (cachedFile)
             return cachedFile;
-        const fd = this.cache.getFileDescriptor(filePath);
-        if (!fd.changed && fd.meta?.data)
-            return fd.meta.data;
+        const cached = this.cache.getCachedFile(filePath);
+        if (cached)
+            return cached;
         sourceText ??= this.fileManager.readFile(filePath);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         if (options.isFixExports || options.isFixTypes) {

package/dist/WorkspaceWorker.js

@@ -7,7 +7,7 @@ import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { createManifest } from './util/package-json.js';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
-import { parseFile } from './typescript/ast-nodes.js';
+import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
@@ -57,7 +57,7 @@ export class WorkspaceWorker {
         this.readFile = readFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
-        this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'worker.getConfigurationHints');
+        this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'getConfigurationHints');
     }
     async init() {
         this.enabledPlugins = await this.determineEnabledPlugins();
@@ -310,7 +310,7 @@ export class WorkspaceWorker {
                     }
                     else {
                         const sourceText = this.readFile(configFilePath);
-                        parsed = sourceText ? parseFile(configFilePath, sourceText) : undefined;
+                        parsed = sourceText ? _parseFile(configFilePath, sourceText) : undefined;
                         parsedConfigCache.set(configFilePath, parsed);
                     }
                 }

package/dist/cli.js

@@ -68,7 +68,7 @@ const main = async () => {
             console.log(`\n${perfObserver.getTimerifiedFunctionsTable()}`);
         if (perfObserver.isMemoryUsageEnabled && !args['memory-realtime'])
             console.log(`\n${perfObserver.getMemoryUsageTable()}`);
-        if (perfObserver.isEnabled) {
+        if (perfObserver.isEnabled || perfObserver.isDurationEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();

package/dist/graph/analyze.js

@@ -28,7 +28,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             }
             if (inExport.hasRefsInFile)
                 return true;
-            if (explorer.isReferenced(filePath, containingExport, { includeEntryExports })[0])
+            if (explorer.isReferenced(filePath, containingExport, { traverseEntries: includeEntryExports })[0])
                 return true;
             if (inExport.referencedIn) {
                 const v = visited ?? new Set();
@@ -63,7 +63,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags) || isInternalProd;
                         if (importsForExport) {
                             const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
-                                includeEntryExports: isIncludeEntryExports,
+                                traverseEntries: isIncludeEntryExports,
                             });
                             if (isIgnored &&
                                 (isReferenced || isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports))) {
@@ -104,7 +104,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                         if (!member.hasRefsInFile) {
                                             const id = `${identifier}.${member.identifier}`;
                                             const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
-                                                includeEntryExports: true,
+                                                traverseEntries: true,
+                                                treatStarAtEntryAsReferenced: true,
                                             });
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
                                             if (!isMemberReferenced) {

package/dist/graph/build.js

@@ -44,6 +44,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
         counselor.addWorkspace(manifest);
     }
+    deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
     collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
     collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
     if (options.configFilePath) {

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

@@ -1,7 +1,8 @@
 import type { ModuleGraph } from '../types/module-graph.ts';
 export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>) => {
     isReferenced: (filePath: string, identifier: string, options: {
-        includeEntryExports: boolean;
+        traverseEntries: boolean;
+        treatStarAtEntryAsReferenced?: boolean;
     }) => [boolean, string | undefined];
     hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
     buildExportsTree: (options: {

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

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

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

@@ -23,9 +23,12 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         seen.add(path);
         const restIds = id.split('.');
         const identifier = restIds.shift();
+        if (options.treatStarAtEntryAsReferenced && isEntryFile && viaStar && restIds.length > 0) {
+            return [true, reExportingEntryFile];
+        }
         const file = graph.get(path)?.importedBy;
         if (!identifier || !file) {
-            return [isEntryFile && viaStar && restIds.length > 0, reExportingEntryFile];
+            return [false, reExportingEntryFile];
         }
         const follow = (sources, nextId, nextViaStar = viaStar) => {
             for (const byFilePath of sources) {
@@ -71,7 +74,7 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                     return [true, reExportingEntryFile];
             }
         }
-        if (isEntryFile && !options.includeEntryExports)
+        if (isEntryFile && !options.traverseEntries)
             return [false, reExportingEntryFile];
         const aliasMap = getAliasReExportMap(file, identifier);
         if (aliasMap) {
@@ -91,7 +94,7 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                 return [true, reExportingEntryFile];
         }
         for (const [namespace, sources] of file.reExportNs) {
-            if (follow(sources, `${namespace}.${id}`)) {
+            if (follow(sources, `${namespace}.${id}`, true)) {
                 return [true, reExportingEntryFile];
             }
         }

package/dist/plugins/docusaurus/helpers.js

@@ -1,5 +1,7 @@
 import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+const isLocalPath = (name) => name.startsWith('.') || name.startsWith('/');
 const FIRST_PARTY_MODULES = new Set([
     'content-docs',
     'content-blog',
@@ -55,12 +57,14 @@ const resolveSidebarPath = (config) => {
     const path = config?.sidebarPath ?? config?.docs?.sidebarPath;
     return typeof path === 'string' ? path : undefined;
 };
-const resolveArrayConfig = ([name, config], type) => {
+const resolveArrayConfig = ([name, config], type, cwd) => {
     if (typeof name !== 'string')
         return [];
-    const resolvedName = resolveModuleName(name, type);
     const sidebarPath = type !== 'theme' ? resolveSidebarPath(config) : undefined;
-    return [toDeferResolve(resolvedName), ...(sidebarPath ? [toProductionEntry(sidebarPath)] : [])];
+    const sidebar = sidebarPath ? [toProductionEntry(sidebarPath)] : [];
+    if (isLocalPath(name))
+        return [toProductionEntry(join(cwd, name)), ...sidebar];
+    return [toDeferResolve(resolveModuleName(name, type)), ...sidebar];
 };
 export const resolveConfigItems = async (items, type, options) => {
     const inputs = new Set();
@@ -70,10 +74,13 @@ export const resolveConfigItems = async (items, type, options) => {
         if (!item)
             continue;
         if (typeof item === 'string') {
-            inputs.add(toDeferResolve(resolveModuleName(item, type)));
+            if (isLocalPath(item))
+                inputs.add(toProductionEntry(join(options.cwd, item)));
+            else
+                inputs.add(toDeferResolve(resolveModuleName(item, type)));
         }
         else if (Array.isArray(item)) {
-            for (const input of resolveArrayConfig(item, type))
+            for (const input of resolveArrayConfig(item, type, options.cwd))
                 inputs.add(input);
         }
         else if (typeof item.configureWebpack === 'function') {

package/dist/plugins/docusaurus/index.js

@@ -5,7 +5,7 @@ import { CORE_CLIENT_API, resolveConfigItems } from './helpers.js';
 const title = 'Docusaurus';
 const enablers = ['@docusaurus/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['docusaurus.config.{js,mjs,ts}'];
+const config = ['docusaurus.config.{js,cjs,mjs,ts,cts,mts}'];
 const production = ['src/pages/**/*.{js,ts,jsx,tsx}', '{blog,docs}/**/*.mdx', 'versioned_docs/**/*.{mdx,jsx,tsx}'];
 const entry = ['babel.config.{js,cjs,mjs,cts}'];
 const resolveStaticAssets = (items, cwd) => {
@@ -30,6 +30,7 @@ const resolveConfig = async (config, options) => {
         toDependency('@docusaurus/module-type-aliases', { optional: true }),
         ...(hasClassicTheme ? [toIgnore('(@theme|@theme-init|@theme-original)/*', 'dependencies')] : []),
         toIgnore(`@docusaurus/(${CORE_CLIENT_API.join('|')})`, 'dependencies'),
+        toIgnore('@generated/.*', 'dependencies'),
         ...(config.future?.experimental_faster ? [toDependency('@docusaurus/faster')] : []),
         ...production.map(id => toProductionEntry(id)),
         ...entry.map(id => toEntry(id)),

package/dist/plugins/hardhat/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Hardhat';
 const enablers = ['hardhat'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['hardhat.config.{js,cjs,mjs,ts}'];
+const entry = ['hardhat.config.{js,cjs,mjs,ts,cts,mts}'];
 const resolve = async () => {
     return [toDependency('hardhat')];
 };

package/dist/plugins/jest/index.js

@@ -6,7 +6,7 @@ import { getReportersDependencies, resolveExtensibleConfig } from './helpers.js'
 const title = 'Jest';
 const enablers = ['jest'];
 const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, enablers) || Boolean(manifest.name?.startsWith('jest-presets'));
-const config = ['jest.config.{js,ts,mjs,cjs,json}', 'package.json'];
+const config = ['jest.config.{js,ts,mjs,cjs,mts,cts,json}', 'package.json'];
 const mocks = ['**/__mocks__/**/*.[jt]s?(x)'];
 const entry = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)', ...mocks];
 const rootDirRe = /<rootDir>/;

package/dist/plugins/nitro/index.js

@@ -4,7 +4,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Nitro';
 const enablers = ['nitropack', 'nitro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['nitro.config.{js,mjs,ts}'];
+const config = ['nitro.config.{js,cjs,mjs,ts,cts,mts}'];
 const production = [
     'server.{js,mjs,ts}',
     'api/**/*.ts',

package/dist/plugins/nuxt/helpers.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { Visitor } from 'oxc-parser';
 import { scriptBodies } from '../../compilers/compilers.js';
-import { parseFile } from '../../typescript/ast-nodes.js';
+import { _parseFile } from '../../typescript/ast-nodes.js';
 import { basename, dirname, isInNodeModules, join } from '../../util/path.js';
 export const getVueSfc = (cwd) => {
     try {
@@ -23,7 +23,7 @@ const readFile = (filePath) => {
         return '';
     }
 };
-export const readAndParseFile = (filePath) => parseFile(filePath, readFile(filePath));
+export const readAndParseFile = (filePath) => _parseFile(filePath, readFile(filePath));
 export const collectIdentifiers = (source, fileName) => {
     const identifiers = new Set();
     const visitor = new Visitor({
@@ -31,7 +31,7 @@ export const collectIdentifiers = (source, fileName) => {
             identifiers.add(node.name);
         },
     });
-    visitor.visit(parseFile(fileName, source).program);
+    visitor.visit(_parseFile(fileName, source).program);
     return identifiers;
 };
 export const collectTemplateInfo = (tree) => {

package/dist/plugins/nuxt/index.js

@@ -8,7 +8,7 @@ import { buildAutoImportMap, collectIdentifiers, collectLocalImportPaths, collec
 const title = 'Nuxt';
 const enablers = ['nuxt', 'nuxt-nightly'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['nuxt.config.{js,mjs,ts}'];
+const config = ['nuxt.config.{js,cjs,mjs,ts,cts,mts}'];
 const entry = ['app.config.ts', '**/*.d.vue.ts'];
 const app = ['app.{vue,jsx,tsx}', 'error.{vue,jsx,tsx}', 'router.options.ts'];
 const layout = (dir = 'layouts') => join(dir, '**/*.{vue,jsx,tsx}');

package/dist/plugins/nx/index.js

@@ -35,6 +35,13 @@ const resolveConfig = async (localConfig, options) => {
         .map(target => target?.executor)
         .filter(executor => executor && !executor.startsWith('.'))
         .map(executor => executor?.split(':')[0]);
+    const expand = (value) => value.replaceAll('{projectRoot}', options.configFileDir).replaceAll('{workspaceRoot}', options.rootCwd);
+    const resolveTargetCwd = (targetCwd) => {
+        if (!targetCwd)
+            return options.cwd;
+        const expanded = expand(targetCwd);
+        return expanded === targetCwd ? join(options.cwd, targetCwd) : expanded;
+    };
     const inputs = targets
         .filter(target => target.executor === 'nx:run-commands' || target.command)
         .flatMap(target => {
@@ -45,8 +52,7 @@ const resolveConfig = async (localConfig, options) => {
             commands = [target.options.command];
         else if (target.options?.commands)
             commands = target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
-        const cwd = target.options?.cwd ? join(options.cwd, target.options.cwd) : options.cwd;
-        return options.getInputsFromScripts(commands, { cwd });
+        return options.getInputsFromScripts(commands.map(expand), { cwd: resolveTargetCwd(target.options?.cwd) });
     });
     const configInputs = targets.flatMap(target => {
         const opts = target.options;