knip 6.39.0 → 6.41.0

package/dist/typescript/resolve-module-names.js

@@ -9,10 +9,20 @@ import { _createSyncModuleResolver, _resolveModuleSync, resolvePackageManifestPa
 function pickStringTarget(value) {
     if (typeof value === 'string')
         return value;
-    if (!value || typeof value !== 'object' || Array.isArray(value))
+    if (!value || typeof value !== 'object')
         return;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const target = pickStringTarget(item);
+            if (target)
+                return target;
+        }
+        return;
+    }
     const obj = value;
-    for (const key of ['default', 'node', 'import', 'require']) {
+    for (const key of Object.keys(obj)) {
+        if (key !== 'default' && key !== 'node' && key !== 'import' && key !== 'require')
+            continue;
         const v = pickStringTarget(obj[key]);
         if (v)
             return v;
@@ -147,12 +157,13 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
     const moduleExtensions = new Set([...DEFAULT_EXTENSIONS, ...customCompilerExtensions, '.json', '.jsonc']);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS, '.json', '.jsonc'];
+    const sourceExtensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions];
     const resolveSync = hasCustomExts || tsConfigFile ? _createSyncModuleResolver(extensions, tsConfigFile) : _resolveModuleSync;
     const pathMappings = compilePathMappings(compilerOptions.scopedPaths);
     const rootDirMappings = compileRootDirs(compilerOptions.scopedRootDirs);
     function toSourcePath(resolvedFileName) {
         if (!hasCustomExts || !customCompilerExtensionsSet.has(extname(resolvedFileName))) {
-            return toSourceFilePath(resolvedFileName) || resolvedFileName;
+            return toSourceFilePath(resolvedFileName, sourceExtensions) || resolvedFileName;
         }
         return resolvedFileName;
     }
@@ -232,7 +243,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             const target = expandPackageTarget(pickStringTarget(workspaceTarget.target), workspaceTarget.patternMatch);
             if (target) {
                 const targetPath = toPackagePath(workspaceTarget.dir, target);
-                const sourcePath = targetPath && toSourceFilePath(targetPath);
+                const sourcePath = targetPath && toSourceFilePath(targetPath, sourceExtensions);
                 if (sourcePath)
                     return toResult(specifier, containingFile, sourcePath);
             }

package/dist/typescript/visitors/walk.js

@@ -408,6 +408,18 @@ const coreVisitorObject = {
             }
         }
     },
+    ArrayExpression(node) {
+        for (const element of node.elements ?? []) {
+            if (element?.type !== 'Identifier')
+                continue;
+            const _import = state.localImportMap.get(element.name);
+            if (_import?.isNamespace) {
+                const internalImport = state.internal.get(_import.filePath);
+                if (internalImport)
+                    addValue(internalImport.import, OPAQUE, state.filePath);
+            }
+        }
+    },
     TSQualifiedName(node) {
         let left = node;
         const parts = [];

package/dist/util/create-options.d.ts

@@ -226,6 +226,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'expo-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'expressive-code'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -236,6 +241,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        flue?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         fumadocs?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -281,6 +291,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        jasmine?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         jest?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -486,6 +501,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        osls?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxfmt?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1198,6 +1218,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'expo-router'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             'expressive-code'?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1208,6 +1233,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            flue?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             fumadocs?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1253,6 +1283,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            jasmine?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             jest?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1458,6 +1493,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            osls?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             oxfmt?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/filter-transitive-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { type Input } from './input.ts';
+export declare const filterTransitiveDependencies: (inputs: Input[], configFilePath: string, readRawFile?: (filePath: string) => string | undefined) => void;

package/dist/util/filter-transitive-dependencies.js

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { collectStringLiterals } from '../typescript/ast-helpers.js';
+import { isDeferResolve, isDependency } from './input.js';
+import { getPackageNameFromSpecifier } from './modules.js';
+import { dirname, isInternal, join } from './path.js';
+const readFile = (filePath) => {
+    try {
+        return readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+};
+export const filterTransitiveDependencies = (inputs, configFilePath, readRawFile = readFile) => {
+    const literals = new Set();
+    const visited = new Set();
+    const collect = (filePath) => {
+        if (visited.has(filePath))
+            return;
+        visited.add(filePath);
+        const sourceText = readRawFile(filePath);
+        if (!sourceText)
+            return;
+        for (const literal of collectStringLiterals(sourceText, filePath)) {
+            literals.add(literal);
+            if (isInternal(literal))
+                collect(join(dirname(filePath), literal));
+        }
+    };
+    collect(configFilePath);
+    for (const input of inputs) {
+        if (!input.optional && (isDeferResolve(input) || isDependency(input))) {
+            const name = getPackageNameFromSpecifier(input.specifier);
+            if (name && !literals.has(name))
+                input.optional = true;
+        }
+    }
+};

package/dist/util/glob-cache.d.ts

@@ -1,4 +1,4 @@
-import type { FSLike } from 'fdir';
+import type { FileSystemAdapter } from 'tinyglobby';
 export declare const initGlobCache: (cacheLocation: string) => void;
 export declare const isGlobCacheEnabled: () => boolean;
 export declare const flushGlobCache: () => void;
@@ -13,6 +13,6 @@ export declare const computeGlobCacheKey: (input: {
 export declare const getCachedGlob: (key: string) => string[] | undefined;
 export declare const createDirTracker: () => {
     dirs: Set<string>;
-    fs: Partial<FSLike>;
+    fs: FileSystemAdapter;
 };
 export declare const setCachedGlob: (key: string, paths: string[], baseDir: string, dirs?: Iterable<string>) => void;

package/dist/util/glob-core.js

@@ -1,8 +1,6 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { basename } from 'node:path';
-import { fdir } from 'fdir';
-import { glob as tinyGlob } from 'tinyglobby';
+import { readdir, readFileSync } from 'node:fs';
+import { escapePath, glob as tinyGlob } from 'tinyglobby';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { compact, partition } from './array.js';
@@ -14,6 +12,15 @@ import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-
 import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
+let gitignoreWorkspaceDirs;
+const isInNestedWorkspace = (gitignoreDir, dir) => {
+    if (!gitignoreWorkspaceDirs)
+        return false;
+    for (let d = gitignoreDir; d.length > dir.length; d = dirname(d))
+        if (gitignoreWorkspaceDirs.has(d))
+            return true;
+    return false;
+};
 let gitignoreReconciler;
 let gitignoreMatcher = (_filePath) => false;
 export const isGitIgnored = (filePath) => gitignoreMatcher(filePath);
@@ -76,22 +83,20 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = new Set();
     const gitignoreFiles = [];
-    let deepFilterMatcher;
-    let prevUnignoreSize = unignores.size;
-    let unignoresArray = [];
-    const pendingIgnores = [];
-    const getMatcher = () => {
-        if (!deepFilterMatcher) {
-            unignoresArray = Array.from(unignores);
-            deepFilterMatcher = picomatch(Array.from(ignores), { ignore: unignoresArray });
-            pendingIgnores.length = 0;
-        }
-        else if (pendingIgnores.length > 0) {
-            const prev = deepFilterMatcher;
-            const incr = picomatch(pendingIgnores.splice(0), { ignore: unignoresArray });
-            deepFilterMatcher = (path) => prev(path) || incr(path);
-        }
-        return deepFilterMatcher;
+    let isIgnored = (_path) => false;
+    let isUnignored = (_path) => false;
+    const pendingIgnores = Array.from(ignores);
+    const pendingUnignores = [];
+    const extend = (matcher, pending) => {
+        if (pending.length === 0)
+            return matcher;
+        const incr = picomatch(pending.splice(0));
+        return (path) => matcher(path) || incr(path);
+    };
+    const isExcluded = (path) => {
+        isIgnored = extend(isIgnored, pendingIgnores);
+        isUnignored = extend(isUnignored, pendingUnignores);
+        return isIgnored(path) && !isUnignored(path);
     };
     const seenGitignoreFiles = new Set();
     const addFile = (filePath, baseDir) => {
@@ -108,6 +113,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         const prevIgnoreSize = ignores.size;
         const patterns = readFileSync(filePath, 'utf8');
         const isRoot = base === '' || base.startsWith('..');
+        const escapedBase = escapePath(base);
         for (const { negated, pattern } of parseAndConvertGitignorePatterns(patterns, ancestor)) {
             if (negated) {
                 if (isRoot) {
@@ -117,7 +123,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                     }
                 }
                 else if (!unignores.has(pattern)) {
-                    const unignore = join(base, pattern);
+                    const unignore = join(escapedBase, pattern);
                     unignores.add(unignore);
                     unignoresForDir.add(unignore);
                 }
@@ -127,7 +133,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                 ignoresForDir.add(pattern);
             }
             else if (!unignores.has(pattern)) {
-                const ignore = join(base, pattern);
+                const ignore = join(escapedBase, pattern);
                 ignores.add(ignore);
                 ignoresForDir.add(ignore);
             }
@@ -143,11 +149,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        if (unignores.size !== prevUnignoreSize) {
-            deepFilterMatcher = undefined;
-            prevUnignoreSize = unignores.size;
-        }
-        else if (ignores.size !== prevIgnoreSize) {
+        for (const p of unignoresForDir)
+            pendingUnignores.push(p);
+        if (ignores.size !== prevIgnoreSize) {
             for (const p of ignoresForDir)
                 if (!GLOBAL_IGNORE_PATTERNS.includes(p))
                     pendingIgnores.push(p);
@@ -168,15 +172,16 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const rootGitignorePath = join(cwd, '.gitignore');
     if (isFile(rootGitignorePath))
         addFile(rootGitignorePath);
+    const root = cwd.length > 1 && cwd.endsWith('/') ? cwd.slice(0, -1) : cwd;
     let isRelevantDir;
     if (workspaceDirs && workspaceDirs.size > 0) {
         const relevantAncestors = new Set();
         const nonRootDirs = new Set();
         for (const wsDir of workspaceDirs) {
-            if (wsDir !== cwd)
+            if (wsDir !== root)
                 nonRootDirs.add(wsDir);
             let dir = wsDir;
-            while (dir.length >= cwd.length) {
+            while (dir.length >= root.length) {
                 relevantAncestors.add(dir);
                 const parent = dirname(dir);
                 if (parent === dir)
@@ -195,24 +200,32 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
             };
         }
     }
-    const cwdPrefixLen = cwd.length + 1;
-    const walkGitignores = async () => {
-        await new fdir()
-            .withFullPaths()
-            .exclude((_dirName, dirPath) => {
-            const absPath = toPosix(dirPath.slice(0, -1));
-            return (isRelevantDir && !isRelevantDir(absPath)) || getMatcher()(absPath.slice(cwdPrefixLen));
-        })
-            .filter((filePath, isDir) => {
-            if (isDir || basename(filePath) !== '.gitignore')
-                return false;
-            addFile(filePath);
-            return true;
-        })
-            .crawl(cwd)
-            .withPromise();
-    };
-    await walkGitignores();
+    const rootPrefixLen = root.length + 1;
+    await new Promise(resolve => {
+        let pending = 0;
+        const walk = (dir) => {
+            pending++;
+            readdir(dir, { withFileTypes: true }, (error, entries) => {
+                if (!error) {
+                    for (const entry of entries) {
+                        if (entry.name === '.gitignore' && (entry.isFile() || entry.isSymbolicLink()))
+                            addFile(`${dir}/.gitignore`);
+                    }
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const absPath = `${dir}/${entry.name}`;
+                        if ((isRelevantDir && !isRelevantDir(absPath)) || isExcluded(absPath.slice(rootPrefixLen)))
+                            continue;
+                        walk(absPath);
+                    }
+                }
+                if (--pending === 0)
+                    resolve();
+            });
+        };
+        walk(root);
+    });
     if (unignores.size > 0) {
         const unignorePaths = new Set();
         for (const u of unignores) {
@@ -269,6 +282,14 @@ export async function glob(_patterns, options) {
             if (prev === dir || dir === '.')
                 break;
         }
+        if (!gitignoreReconciler) {
+            const prefix = `${options.dir}/`;
+            for (const [gitignoreDir, cacheForDir] of cachedGitIgnores) {
+                if (gitignoreDir.startsWith(prefix) && !isInNestedWorkspace(gitignoreDir, options.dir)) {
+                    _ignore.push(...cacheForDir.ignores);
+                }
+            }
+        }
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     }
     const ignorePatterns = (cachedIgnores ?? _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
@@ -301,6 +322,8 @@ export function reconcileGitignoredPaths(paths, cwd) {
 }
 export async function getGitIgnoredHandler(options, workspaceDirs) {
     cachedGitIgnores.clear();
+    cachedGlobIgnores.clear();
+    gitignoreWorkspaceDirs = workspaceDirs;
     gitignoreReconciler = undefined;
     gitignoreMatcher = () => false;
     gitignoreFingerprint = '';

package/dist/util/glob.js

@@ -4,8 +4,18 @@ import { computeGlobCacheKey, createDirTracker, getCachedGlob, isGlobCacheEnable
 import { getGitignoreFingerprint, glob, reconcileGitignoredPaths } from './glob-core.js';
 import { timerify } from './Performance.js';
 import { isAbsolute, join, relative } from './path.js';
-const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
-const prependDirToPatterns = (cwd, dir, patterns) => compact([patterns].flat().map(p => removeProductionSuffix(prepend(p, relative(cwd, dir))))).sort(negatedLast);
+const prepend = (pattern, cwd, relativePath) => {
+    const isNegated = pattern.startsWith('!');
+    const id = isNegated ? pattern.slice(1) : pattern;
+    if (id && !isAbsolute(id) && !relativePath)
+        return pattern;
+    const globPattern = isAbsolute(id) ? relative(cwd, id) : join(relativePath, id);
+    return isNegated ? `!${globPattern}` : globPattern;
+};
+const prependDirToPatterns = (cwd, dir, patterns) => {
+    const relativePath = dir === cwd ? '' : relative(cwd, dir);
+    return compact(patterns.map(p => removeProductionSuffix(prepend(p, cwd, relativePath)))).sort(negatedLast);
+};
 export const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 export const prependDirToPattern = (dir, pattern) => {
@@ -48,7 +58,7 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
 };
 const syncGlob = ({ cwd, patterns }) => {
     const cacheEnabled = isGlobCacheEnabled();
-    const patternList = Array.isArray(patterns) ? patterns : [patterns];
+    const patternList = [patterns].flat().map(pattern => prepend(pattern, cwd, ''));
     const cacheKey = cacheEnabled
         ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false, gitignoreFingerprint: '' })
         : '';
@@ -58,7 +68,7 @@ const syncGlob = ({ cwd, patterns }) => {
             return cached;
     }
     const tracker = cacheEnabled ? createDirTracker() : undefined;
-    const paths = globSync(patterns, {
+    const paths = globSync(patternList, {
         cwd,
         absolute: true,
         followSymbolicLinks: false,
@@ -69,12 +79,7 @@ const syncGlob = ({ cwd, patterns }) => {
         setCachedGlob(cacheKey, paths, cwd, tracker?.dirs);
     return paths;
 };
-const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
-    cwd,
-    dir: cwd,
-    onlyDirectories: true,
-    gitignore,
-});
+const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns.map(pattern => prepend(pattern, cwd, '')), { cwd, dir: cwd, onlyDirectories: true, gitignore });
 export const _glob = timerify(defaultGlob);
 export const _syncGlob = timerify(syncGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/load-tsconfig.d.ts

@@ -9,5 +9,5 @@ interface TSConfigInfo {
     sourceMapPairs: SourceMap[];
     paths: Record<string, string[]> | undefined;
 }
-export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<TSConfigInfo>;
+export declare const loadTSConfig: (tsConfigFilePath: string, isUseTscFiles?: boolean, visited?: Set<string>) => Promise<TSConfigInfo>;
 export {};

package/dist/util/load-tsconfig.js

@@ -2,19 +2,19 @@ import { parseTsconfig } from 'get-tsconfig';
 import { compact } from './array.js';
 import { isFile } from './fs.js';
 import { _syncGlob } from './glob.js';
-import { dirname, isAbsolute, join, toAbsolute, toPosix } from './path.js';
+import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
     const base = last >= 0 ? p.slice(last + 1) : p;
     return base !== '.' && base !== '..' && base.includes('.');
 };
-const resolvePatterns = (patterns, dir, expandDirs = false) => {
+const toRelativePatterns = (patterns, dir) => {
     if (!patterns)
         return undefined;
     return patterns.map(p => {
-        const resolved = isAbsolute(p) ? p : join(dir, p);
-        return expandDirs && !hasGlobChar(p) && !hasExtension(p) ? join(resolved, '**/*') : resolved;
+        const pattern = isAbsolute(p) ? relative(dir, p) : p;
+        return hasGlobChar(p) || hasExtension(p) ? pattern : join(pattern, '**/*');
     });
 };
 const getImplicitBaseUrl = (compilerOptions) => {
@@ -54,11 +54,11 @@ const expandFileNames = (dir, compilerOptions, include, exclude, files) => {
         for (const file of files)
             result.push(file);
     }
-    const effectiveExclude = [...(exclude ?? []), join(dir, 'node_modules/**')];
+    const effectiveExclude = [...(exclude ?? []), 'node_modules/**'];
     if (compilerOptions.outDir) {
-        effectiveExclude.push(join(compilerOptions.outDir, '**'));
+        effectiveExclude.push(join(relative(dir, compilerOptions.outDir), '**'));
     }
-    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE.map(p => join(dir, p)));
+    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE);
     if (effectiveInclude) {
         const negated = effectiveExclude.map(p => `!${p}`);
         const globbed = _syncGlob({ patterns: [...effectiveInclude, ...negated], cwd: dir });
@@ -108,7 +108,7 @@ const EMPTY = {
     sourceMapPairs: [],
     paths: undefined,
 };
-export const loadTSConfig = async (tsConfigFilePath) => {
+export const loadTSConfig = async (tsConfigFilePath, isUseTscFiles = false, visited = new Set([tsConfigFilePath])) => {
     if (!isFile(tsConfigFilePath))
         return { isFile: false, ...EMPTY };
     try {
@@ -127,10 +127,20 @@ export const loadTSConfig = async (tsConfigFilePath) => {
         if (config.references?.length) {
             walkReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]), sourceMapPairs, tsconfigPaths);
         }
-        const include = resolvePatterns(config.include, dir, true);
-        const exclude = resolvePatterns(config.exclude, dir, true);
-        const files = resolvePatterns(config.files, dir);
+        const include = toRelativePatterns(config.include, dir);
+        const exclude = toRelativePatterns(config.exclude, dir);
+        const files = config.files?.map(p => toAbsolute(p, dir));
         const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+        if (isUseTscFiles && config.references) {
+            for (const ref of config.references) {
+                const refPath = resolveReference(ref.path, dir);
+                if (!refPath?.startsWith(`${dir}/`) || visited.has(refPath))
+                    continue;
+                visited.add(refPath);
+                for (const filePath of (await loadTSConfig(refPath, true, visited)).fileNames)
+                    fileNames.push(filePath);
+            }
+        }
         const paths = Object.keys(tsconfigPaths).length > 0 ? tsconfigPaths : undefined;
         return { isFile: true, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths };
     }

package/dist/util/module-graph.js

@@ -87,13 +87,18 @@ const addValues = (map, id, values) => {
         for (const v of values)
             existing.add(v);
     else
-        map.set(id, values);
+        map.set(id, new Set(values));
 };
 const addNsValues = (map, id, value) => {
     const existing = map.get(id);
-    if (existing)
+    if (existing) {
         for (const [ns, v] of value)
             addValues(existing, ns, v);
-    else
-        map.set(id, value);
+    }
+    else {
+        const copy = new Map();
+        for (const [ns, v] of value)
+            copy.set(ns, new Set(v));
+        map.set(id, copy);
+    }
 };