knip 6.16.0 → 6.16.1

package/dist/ProjectPrincipal.d.ts

@@ -19,6 +19,7 @@ export declare class ProjectPrincipal {
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     private paths;
+    private rootDirs;
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
@@ -31,6 +32,7 @@ export declare class ProjectPrincipal {
     constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
+    addRootDirs(rootDirs: string[] | undefined, scope: string): void;
     init(): void;
     readFile(filePath: string): string;
     private hasAcceptedExtension;

package/dist/ProjectPrincipal.js

@@ -29,6 +29,7 @@ export class ProjectPrincipal {
     syncCompilers = new Map();
     asyncCompilers = new Map();
     paths = new Map();
+    rootDirs = new Map();
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
@@ -72,6 +73,12 @@ export class ProjectPrincipal {
         }
         this.paths.set(scope, scoped);
     }
+    addRootDirs(rootDirs, scope) {
+        if (!rootDirs?.length)
+            return;
+        const scoped = this.rootDirs.get(scope) ?? [];
+        this.rootDirs.set(scope, compact([...scoped, ...rootDirs]));
+    }
     init() {
         this.extensions = new Set([
             ...DEFAULT_EXTENSIONS,
@@ -79,7 +86,8 @@ export class ProjectPrincipal {
         ]);
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
-        this.resolveModule = createCustomModuleResolver({ scopedPaths }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
+        const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
+        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);

package/dist/graph/build.js

@@ -129,6 +129,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         for (const dep of getManifestImportDependencies(manifest))
             deputy.addReferencedDependency(name, dep);
         principal.addPaths(config.paths, dir, dir);
+        principal.addRootDirs(compilerOptions.rootDirs, dir);
         const inputsFromPlugins = await worker.runPlugins();
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));

package/dist/types/project.d.ts

@@ -22,6 +22,7 @@ export interface CompilerOptions {
         name: string;
     } | string>;
     rootDir?: string;
+    rootDirs?: string[];
     skipDefaultLibCheck?: boolean;
     skipLibCheck?: boolean;
     sourceMap?: boolean;

package/dist/typescript/resolve-module-names.d.ts

@@ -4,8 +4,13 @@ type ScopedPaths = Array<{
     scope: string;
     paths: Record<string, string[]>;
 }>;
+type ScopedRootDirs = Array<{
+    scope: string;
+    rootDirs: string[];
+}>;
 export declare function clearModuleResolutionCaches(): void;
 export declare function createCustomModuleResolver(compilerOptions: {
     scopedPaths?: ScopedPaths;
+    scopedRootDirs?: ScopedRootDirs;
 }, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler): ResolveModule;
 export {};

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

@@ -47,12 +47,22 @@ function compilePathMappings(scopedPaths) {
     mappings.sort((a, b) => b.scope.length - a.scope.length);
     return mappings;
 }
+function compileRootDirs(scopedRootDirs) {
+    if (!scopedRootDirs)
+        return undefined;
+    const scoped = scopedRootDirs.filter(({ rootDirs }) => rootDirs.length > 1);
+    if (scoped.length === 0)
+        return undefined;
+    scoped.sort((a, b) => b.scope.length - a.scope.length);
+    return scoped;
+}
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspaceManifestImports) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS];
     const resolveSync = hasCustomExts ? _createSyncModuleResolver(extensions) : _resolveModuleSync;
     const pathMappings = compilePathMappings(compilerOptions.scopedPaths);
+    const rootDirMappings = compileRootDirs(compilerOptions.scopedRootDirs);
     function toSourcePath(resolvedFileName) {
         if (!hasCustomExts || !customCompilerExtensionsSet.has(extname(resolvedFileName))) {
             return toSourceFilePath(resolvedFileName) || resolvedFileName;
@@ -107,6 +117,25 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 }
             }
         }
+        if (rootDirMappings && !isAbsolute(specifier)) {
+            const dir = dirname(containingFile);
+            for (const { scope, rootDirs } of rootDirMappings) {
+                if (dir !== scope && !dir.startsWith(`${scope}/`))
+                    continue;
+                for (const rootDir of rootDirs) {
+                    if (dir !== rootDir && !dir.startsWith(`${rootDir}/`))
+                        continue;
+                    const relPath = dir === rootDir ? '' : dir.slice(rootDir.length + 1);
+                    for (const targetRoot of rootDirs) {
+                        if (targetRoot === rootDir)
+                            continue;
+                        const resolved = resolveSync(join(targetRoot, relPath, specifier), containingFile);
+                        if (resolved)
+                            return toResult(resolved);
+                    }
+                }
+            }
+        }
         if (specifier.startsWith('#') && findWorkspaceManifestImports) {
             const ws = findWorkspaceManifestImports(containingFile);
             if (ws) {

package/dist/util/load-tsconfig.js

@@ -94,6 +94,8 @@ export const loadTSConfig = async (tsConfigFilePath) => {
             compilerOptions.outDir = absDir(compilerOptions.outDir, dir);
         if (compilerOptions.rootDir)
             compilerOptions.rootDir = absDir(compilerOptions.rootDir, dir);
+        if (compilerOptions.rootDirs)
+            compilerOptions.rootDirs = compilerOptions.rootDirs.map(d => absDir(d, dir));
         if (compilerOptions.paths) {
             compilerOptions.pathsBasePath ??= dir;
         }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.16.0";
+export declare const version = "6.16.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.16.0';
+export const version = '6.16.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.16.0",
+  "version": "6.16.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",