knip 2.0.0-alpha.9 → 2.0.0-beta.0

package/dist/binaries/resolvers/node.js

@@ -1,11 +1,11 @@
 import parseArgs from 'minimist';
 import { isInNodeModules, join } from '../../util/path.js';
-import { tryResolve } from '../../util/require.js';
+import { _tryResolve } from '../../util/require.js';
 const tryResolveFilePath = (cwd, specifier, fallback) => {
     if (specifier) {
         const filePath = join(cwd, specifier);
         if (!isInNodeModules(filePath)) {
-            const resolvedFilePath = tryResolve(filePath);
+            const resolvedFilePath = _tryResolve(filePath, cwd);
             if (resolvedFilePath)
                 return [resolvedFilePath];
         }

package/dist/configuration-chief.d.ts

@@ -6,7 +6,7 @@ type ConfigurationManagerOptions = {
     cwd: string;
     isProduction: boolean;
 };
-type Workspace = {
+export type Workspace = {
     name: string;
     pkgName?: string;
     dir: string;
@@ -41,13 +41,7 @@ export declare class ConfigurationChief {
     private getManifestWorkspaces;
     private getAdditionalWorkspaces;
     private getAllWorkspaces;
-    getEnabledWorkspaces(): {
-        name: string;
-        pkgName: string | undefined;
-        dir: string;
-        config: WorkspaceConfiguration;
-        ancestors: string[];
-    }[];
+    getEnabledWorkspaces(): Workspace[];
     getDescendentWorkspaces(name: string): string[];
     getIgnoredWorkspaces(): string[];
     getIgnoredWorkspacesFor(name: string): string[];

package/dist/configuration-chief.js

@@ -191,7 +191,7 @@ export class ConfigurationChief {
         const workspaces = rawWorkspaceArg
             ? [workspace, ...allWorkspaces.reduce(getAncestors(workspace), [])]
             : allWorkspaces;
-        return workspaces.sort(byPathDepth).map(name => ({
+        return workspaces.sort(byPathDepth).map((name) => ({
             name,
             pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
             dir: join(this.cwd, name),

package/dist/dependency-deputy.d.ts

@@ -1,4 +1,4 @@
-import { WorkspaceConfiguration } from './types/config.js';
+import { Workspace } from './configuration-chief.js';
 import type { Issue } from './types/issues.js';
 import type { WorkspaceManifests } from './types/workspace.js';
 import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
@@ -38,12 +38,7 @@ export declare class DependencyDeputy {
     addReferencedDependency(workspaceName: string, packageName: string): void;
     addPeerDependencies(workspaceName: string, peerDependencies: Map<string, Set<string>>): void;
     getPeerDependencies(workspaceName: string, dependency: string): string[];
-    maybeAddReferencedExternalDependency(workspace: {
-        name: string;
-        dir: string;
-        config: WorkspaceConfiguration;
-        ancestors: string[];
-    }, packageName: string): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
     private isInDependencies;
     settleDependencyIssues(): {
         dependencyIssues: Issue[];

package/dist/dependency-deputy.js

@@ -67,6 +67,8 @@ export class DependencyDeputy {
     maybeAddReferencedExternalDependency(workspace, packageName) {
         if (isBuiltin(packageName))
             return true;
+        if (packageName === workspace.pkgName)
+            return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
         if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))

package/dist/index.js

@@ -5,13 +5,14 @@ import { DependencyDeputy } from './dependency-deputy.js';
 import { IssueCollector } from './issue-collector.js';
 import { PrincipalFactory } from './principal-factory.js';
 import { compact } from './util/array.js';
-import { debugLogObject, debugLogArray } from './util/debug.js';
+import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
 import { ConfigurationError } from './util/errors.js';
 import { findFile } from './util/fs.js';
 import { _glob } from './util/glob.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from './util/modules.js';
 import { dirname, isInNodeModules, join, isInternal, isAbsolute } from './util/path.js';
-import { _require, _resolve } from './util/require.js';
+import { _resolveSpecifier, _tryResolve } from './util/require.js';
+import { _require } from './util/require.js';
 import { loadTSConfig as loadCompilerOptions } from './util/tsconfig-loader.js';
 import { WorkspaceWorker } from './workspace-worker.js';
 export const main = async (unresolvedConfiguration) => {
@@ -21,8 +22,8 @@ export const main = async (unresolvedConfiguration) => {
     const deputy = new DependencyDeputy({ isStrict });
     const factory = new PrincipalFactory();
     const collector = new IssueCollector({ cwd });
-    const console = new ConsoleStreamer({ isEnabled: isShowProgress });
-    console.cast('Reading workspace configuration(s)...');
+    const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
+    streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
     const compilers = chief.getCompilers();
     const workspaces = chief.getEnabledWorkspaces();
@@ -33,7 +34,7 @@ export const main = async (unresolvedConfiguration) => {
         const { name, dir, config, ancestors } = workspace;
         const { paths, ignoreDependencies } = config;
         const isRoot = name === ROOT_WORKSPACE_NAME;
-        console.cast(`Analyzing workspace (${name})...`);
+        streamer.cast(`Analyzing workspace (${name})...`);
         const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
         const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
         if (!manifestPath || !manifest)
@@ -122,9 +123,14 @@ export const main = async (unresolvedConfiguration) => {
         enabledPluginsStore.set(name, enabledPlugins);
         referencedDependencies.forEach(([containingFilePath, specifier]) => {
             if (isInternal(specifier)) {
-                const filePath = _resolve(isAbsolute(specifier) ? specifier : join(dirname(containingFilePath), specifier));
-                if (filePath)
+                const absSpecifier = isAbsolute(specifier) ? specifier : join(dirname(containingFilePath), specifier);
+                const filePath = _tryResolve(absSpecifier, containingFilePath);
+                if (filePath) {
                     principal.addEntryPath(filePath);
+                }
+                else {
+                    collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+                }
             }
             else {
                 if (isInNodeModules(specifier)) {
@@ -139,17 +145,21 @@ export const main = async (unresolvedConfiguration) => {
                     if (!isHandled)
                         collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
                     const otherWorkspace = chief.findWorkspaceByPackageName(packageName);
-                    if (otherWorkspace && specifier !== packageName && workspace !== otherWorkspace) {
-                        const relativeSpecifier = specifier.replace(new RegExp(`^${packageName}`), '.');
-                        const filePath = _resolve(join(otherWorkspace.dir, relativeSpecifier));
-                        if (filePath)
+                    if (otherWorkspace && specifier !== packageName) {
+                        const filePath = _resolveSpecifier(otherWorkspace.dir, specifier);
+                        if (filePath) {
                             principal.addEntryPath(filePath);
+                        }
+                        else {
+                            collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+                        }
                     }
                 }
             }
         });
     }
     const principals = factory.getPrincipals();
+    debugLog(`Installed ${principals.length} principals for ${workspaces.length} workspaces`);
     for (const principal of principals) {
         const exportedSymbols = new Map();
         const importedSymbols = new Map();
@@ -164,8 +174,13 @@ export const main = async (unresolvedConfiguration) => {
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
                     const importedWorkspace = chief.findWorkspaceByPackageName(packageName);
-                    if (importedWorkspace && importedWorkspace !== workspace) {
-                        external.add(importItems.specifier);
+                    if (importedWorkspace) {
+                        if (importedWorkspace === workspace) {
+                            principal.addEntryPath(specifierFilePath);
+                        }
+                        else {
+                            external.add(importItems.specifier);
+                        }
                     }
                     if (!importedSymbols.has(specifierFilePath)) {
                         importedSymbols.set(specifierFilePath, importItems);
@@ -204,9 +219,9 @@ export const main = async (unresolvedConfiguration) => {
             const hasFile = (file) => entryPaths.has(file) || isExportedInEntryFile(importedSymbols.get(file));
             return isReExported ? Array.from(isReExportedBy).some(hasFile) : false;
         };
-        console.cast('Running async compilers...');
+        streamer.cast('Running async compilers...');
         await principal.runAsyncCompilers();
-        console.cast('Connecting the dots...');
+        streamer.cast('Connecting the dots...');
         const analyzedFiles = new Set();
         let size = principal.entryPaths.size;
         let round = 0;
@@ -214,7 +229,7 @@ export const main = async (unresolvedConfiguration) => {
             size = principal.entryPaths.size;
             const resolvedFiles = principal.getUsedResolvedFiles();
             const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
-            debugLogArray(`Analyzing used resolved files [${++round}/${principals.indexOf(principal) + 1}]`, files);
+            debugLogArray(`Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
             files.forEach(filePath => {
                 analyzeSourceFile(filePath);
                 analyzedFiles.add(filePath);
@@ -223,7 +238,7 @@ export const main = async (unresolvedConfiguration) => {
         const unusedFiles = principal.getUnreferencedFiles();
         collector.addFilesIssues(unusedFiles);
         collector.addTotalFileCount(analyzedFiles.size + unusedFiles.length);
-        console.cast('Analyzing source files...');
+        streamer.cast('Analyzing source files...');
         for (const [filePath, exportItems] of exportedSymbols.entries()) {
             const importedModule = importedSymbols.get(filePath);
             if (importedModule) {
@@ -272,6 +287,6 @@ export const main = async (unresolvedConfiguration) => {
             devDependencyIssues.forEach(issue => collector.addIssue(issue));
     }
     const { issues, counters } = collector.getIssues();
-    console.clear();
+    streamer.clear();
     return { report, issues, counters };
 };

package/dist/plugins/eslint/helpers.js

@@ -36,6 +36,7 @@ export const getDependenciesDeep = async (configFilePath, dependencies = new Set
                 if (isInternal(extend)) {
                     const filePath = isAbsolute(extend) ? extend : join(dirname(configFilePath), extend);
                     const extendConfigFilePath = _resolve(filePath);
+                    dependencies.add(extendConfigFilePath);
                     addAll(await getDependenciesDeep(extendConfigFilePath, dependencies, options));
                 }
             }

package/dist/principal-factory.d.ts

@@ -7,7 +7,6 @@ type Principal = {
     principal: ProjectPrincipal;
     cwds: Set<string>;
     paths: Set<string>;
-    isDefaultBaseUrl: boolean;
 };
 type Principals = Set<Principal>;
 type Options = {

package/dist/principal-factory.js

@@ -9,7 +9,6 @@ const mergePaths = (cwd, compilerOptions = {}, paths = {}) => {
     }, {});
     return compilerOptions;
 };
-const hasDefaultBaseUrl = (compilerOptions) => !compilerOptions.baseUrl || /^\.\/?$/.test(compilerOptions.baseUrl);
 export class PrincipalFactory {
     principals = new Set();
     getPrincipal({ cwd, compilerOptions, report, paths, compilers }) {
@@ -24,10 +23,13 @@ export class PrincipalFactory {
         }
     }
     findReusablePrincipal(compilerOptions) {
-        if (!hasDefaultBaseUrl(compilerOptions))
-            return;
         const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
-        const principal = Array.from(this.principals).find(principal => principal.isDefaultBaseUrl && workspacePaths.every(p => !principal.paths.has(p)));
+        const principal = Array.from(this.principals).find(principal => {
+            if (compilerOptions.baseUrl === principal.principal.compilerOptions.baseUrl) {
+                return workspacePaths.every(p => !principal.paths.has(p));
+            }
+            return !compilerOptions.baseUrl;
+        });
         return principal;
     }
     linkPrincipal(principal, cwd, paths) {
@@ -38,9 +40,8 @@ export class PrincipalFactory {
     addNewPrincipal({ cwd, compilerOptions, report, compilers }) {
         const principal = new ProjectPrincipal({ cwd, compilerOptions, report, compilers });
         const paths = new Set(Object.keys(compilerOptions?.paths ?? {}));
-        const isDefaultBaseUrl = hasDefaultBaseUrl(compilerOptions);
         compilerOptions.baseUrl = join(cwd, compilerOptions.baseUrl ?? '.');
-        this.principals.add({ principal, cwds: new Set([cwd]), paths, isDefaultBaseUrl });
+        this.principals.add({ principal, cwds: new Set([cwd]), paths });
         return principal;
     }
     getPrincipals() {

package/dist/typescript/ast-walker.js

@@ -1,5 +1,6 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
+import { isInNodeModules } from '../util/path.js';
 import * as ast from './ast-helpers.js';
 export const getImportsAndExports = (sourceFile, options) => {
     const internalImports = new Map();
@@ -8,6 +9,33 @@ export const getImportsAndExports = (sourceFile, options) => {
     const exports = new Map();
     const aliasedExports = {};
     const importedInternalSymbols = new Map();
+    const addInternalImport = ({ identifier = '__anonymous', specifier, symbol, filePath, }) => {
+        const isStar = identifier === '*';
+        const isReExported = Boolean(isStar && !symbol);
+        if (!internalImports.has(filePath)) {
+            internalImports.set(filePath, {
+                specifier,
+                isStar,
+                isReExported,
+                isReExportedBy: new Set(),
+                symbols: new Set(),
+            });
+        }
+        const internalImport = internalImports.get(filePath);
+        if (isReExported) {
+            internalImport.isReExported = isReExported;
+            internalImport.isReExportedBy.add(sourceFile.fileName);
+        }
+        if (isStar) {
+            internalImport.isStar = isStar;
+        }
+        if (!isStar) {
+            internalImport.symbols.add(identifier);
+        }
+        if (isStar && symbol) {
+            importedInternalSymbols.set(symbol, filePath);
+        }
+    };
     const addImport = ({ specifier, symbol, identifier = '__anonymous' }) => {
         if (isBuiltin(specifier))
             return;
@@ -16,7 +44,10 @@ export const getImportsAndExports = (sourceFile, options) => {
             const filePath = module.resolvedModule.resolvedFileName;
             if (filePath) {
                 if (module.resolvedModule.isExternalLibraryImport) {
-                    if (ast.isDeclarationFileExtension(module.resolvedModule.extension)) {
+                    if (!isInNodeModules(filePath)) {
+                        addInternalImport({ identifier, specifier, symbol, filePath });
+                    }
+                    else if (ast.isDeclarationFileExtension(module.resolvedModule.extension)) {
                         externalImports.add(specifier);
                     }
                     else {
@@ -24,31 +55,7 @@ export const getImportsAndExports = (sourceFile, options) => {
                     }
                 }
                 else {
-                    const isStar = identifier === '*';
-                    const isReExported = Boolean(isStar && !symbol);
-                    if (!internalImports.has(filePath)) {
-                        internalImports.set(filePath, {
-                            specifier,
-                            isStar,
-                            isReExported,
-                            isReExportedBy: new Set(),
-                            symbols: new Set(),
-                        });
-                    }
-                    const internalImport = internalImports.get(filePath);
-                    if (isReExported) {
-                        internalImport.isReExported = isReExported;
-                        internalImport.isReExportedBy.add(sourceFile.fileName);
-                    }
-                    if (isStar) {
-                        internalImport.isStar = isStar;
-                    }
-                    if (!isStar) {
-                        internalImport.symbols.add(identifier);
-                    }
-                    if (isStar && symbol) {
-                        importedInternalSymbols.set(symbol, filePath);
-                    }
+                    addInternalImport({ identifier, specifier, symbol, filePath });
                 }
             }
         }

package/dist/typescript/createHosts.js

@@ -1,12 +1,13 @@
 import { createRequire } from 'node:module';
 import { EOL } from 'node:os';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import ts from 'typescript';
 import { createCustomModuleResolver } from './resolveModuleNames.js';
 import { SourceFileManager } from './SourceFileManager.js';
 import { createCustomSys } from './sys.js';
 const cwd = process.cwd();
-const require = createRequire(import.meta.url);
+const require = createRequire(pathToFileURL(import.meta.url));
 const libLocation = path.dirname(require.resolve('typescript', { paths: [cwd] }));
 const fileManager = new SourceFileManager();
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers }) => {

package/dist/util/glob.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="nano-memoize" />
 export declare const prependDirToPattern: (workingDir: string, pattern: string) => string;
 export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;
@@ -13,8 +12,8 @@ interface GlobOptions extends BaseGlobOptions {
     workingDir?: string;
     gitignore?: boolean;
 }
-export declare const _glob: (({ cwd, workingDir, patterns, ignore, gitignore }: GlobOptions) => Promise<string[]>) & import("nano-memoize").nanomemoize;
+export declare const _glob: ({ cwd, workingDir, patterns, ignore, gitignore }: GlobOptions) => Promise<string[]>;
 export declare const _pureGlob: ({ cwd, patterns, ignore }: BaseGlobOptions) => Promise<string[]>;
-export declare const _firstGlob: (({ cwd, patterns }: BaseGlobOptions) => Promise<string | Buffer | undefined>) & import("nano-memoize").nanomemoize;
+export declare const _firstGlob: ({ cwd, patterns }: BaseGlobOptions) => Promise<string | Buffer | undefined>;
 export declare const _dirGlob: ({ cwd, patterns }: BaseGlobOptions) => Promise<string[]>;
 export {};

package/dist/util/glob.js

@@ -1,6 +1,5 @@
 import fg from 'fast-glob';
 import { globby } from 'globby';
-import memoize from 'nano-memoize';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { compact } from './array.js';
 import { debugLogObject } from './debug.js';
@@ -45,12 +44,7 @@ const dirGlob = async ({ cwd, patterns }) => globby(patterns, {
     cwd,
     onlyDirectories: true,
 });
-const memoOptions = { serializer: JSON.stringify, callTimeout: 0 };
-const memoizedGlob = memoize(glob, memoOptions);
-Object.defineProperty(memoizedGlob, 'name', { value: 'glob' });
-const memoizedFirstGlob = memoize(firstGlob, memoOptions);
-Object.defineProperty(memoizedFirstGlob, 'name', { value: 'firstGlob' });
-export const _glob = timerify(memoizedGlob);
+export const _glob = timerify(glob);
 export const _pureGlob = timerify(pureGlob);
-export const _firstGlob = timerify(memoizedFirstGlob);
+export const _firstGlob = timerify(firstGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/require.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-export declare const tryResolve: (specifier: string) => string | undefined;
 export declare const _require: NodeRequire;
 export declare const _resolve: (specifier: string) => string;
+export declare const _tryResolve: (specifier: string, from: string) => string | undefined;
+export declare const _resolveSpecifier: (dir: string, specifier: string) => string | undefined;

package/dist/util/require.js

@@ -1,14 +1,31 @@
-import { createRequire } from 'node:module';
-import { toPosix } from './path.js';
+import { createRequire as nodeCreateRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { debugLog } from './debug.js';
+import { getPackageNameFromModuleSpecifier } from './modules.js';
+import { cwd, toPosix, join } from './path.js';
 import { timerify } from './performance.js';
-const require = createRequire(process.cwd());
+const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
+const require = createRequire();
 const resolve = (specifier) => toPosix(require.resolve(specifier));
-export const tryResolve = (specifier) => {
+const tryResolve = (specifier, from) => {
     try {
         return resolve(specifier);
     }
-    catch (error) {
+    catch {
+        debugLog(`Unable to resolve ${specifier} (from ${from})`);
+    }
+};
+const resolveSpecifier = (dir, specifier) => {
+    try {
+        const require = createRequire(join(dir, 'package.json'));
+        return toPosix(require.resolve(specifier));
+    }
+    catch {
+        const relativeSpecifier = specifier.replace(getPackageNameFromModuleSpecifier(specifier), '.');
+        return tryResolve(join(dir, relativeSpecifier), dir);
     }
 };
 export const _require = timerify(require);
 export const _resolve = timerify(resolve);
+export const _tryResolve = timerify(tryResolve);
+export const _resolveSpecifier = timerify(resolveSpecifier);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.0.0-alpha.9";
+export declare const version = "2.0.0-beta.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.0.0-alpha.9';
+export const version = '2.0.0-beta.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0-beta.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -51,7 +51,6 @@
     "js-yaml": "^4.1.0",
     "micromatch": "^4.0.5",
     "minimist": "^1.2.8",
-    "nano-memoize": "^2.0.0",
     "pretty-ms": "^8.0.0",
     "strip-json-comments": "^5.0.0",
     "summary": "^2.1.0",