knip 6.9.0 → 6.11.0

package/dist/DependencyDeputy.d.ts

@@ -35,6 +35,7 @@ export declare class DependencyDeputy {
         optionalPeerDependencies: DependencySet;
         requiredPeerDependencies: DependencyArray;
         allDependencies: DependencySet;
+        engines: Record<string, string>;
         ignoreDependencies: (string | RegExp)[];
         ignoreBinaries: (string | RegExp)[];
         ignoreUnresolved: (string | RegExp)[];
@@ -57,7 +58,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {

package/dist/DependencyDeputy.js

@@ -73,6 +73,7 @@ export class DependencyDeputy {
             optionalPeerDependencies,
             requiredPeerDependencies,
             allDependencies: new Set(allDependencies),
+            engines: manifest.engines ?? {},
         });
     }
     getWorkspaceManifest(workspaceName) {
@@ -128,7 +129,7 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly) {
+    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly) {
         if (!this.isReportDependencies)
             return true;
         if (isBuiltin(packageName))
@@ -141,13 +142,16 @@ export class DependencyDeputy {
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOnly));
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
         const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName, isDevOnly));
-        if (closestWorkspaceName || closestWorkspaceNameForTypes) {
-            if (closestWorkspaceName)
-                this.addReferencedDependency(closestWorkspaceName, packageName);
-            if (closestWorkspaceNameForTypes && !this.hasTypesIncluded.get(closestWorkspaceNameForTypes)?.has(packageName))
-                this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
+        if (closestWorkspaceNameForTypes && !this.hasTypesIncluded.get(closestWorkspaceNameForTypes)?.has(packageName))
+            this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
+        if (closestWorkspaceName) {
+            this.addReferencedDependency(closestWorkspaceName, packageName);
             return true;
         }
+        if (closestWorkspaceNameForTypes && isTypeOnly)
+            return true;
+        if (this._manifests.get(workspace.name)?.engines[packageName])
+            return true;
         this.addReferencedDependency(workspace.name, packageName);
         return false;
     }

package/dist/cli.js

@@ -46,6 +46,7 @@ const main = async () => {
             cwd: options.cwd,
             configFilePath: options.configFilePath,
             isDisableConfigHints: options.isDisableConfigHints,
+            isDisableTagHints: options.isDisableTagHints,
             isProduction: options.isProduction,
             isShowProgress: options.isShowProgress,
             isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,

package/dist/graph/analyze.js

@@ -5,7 +5,8 @@ import { shouldCountRefs } from '../typescript/visitors/helpers.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { perfObserver } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
-import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
+import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, isAlwaysIgnored } from '../util/tag.js';
+import { INTERNAL_TAG } from '../constants.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
@@ -54,9 +55,10 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     }
                     const importsForExport = file.importedBy;
                     for (const [identifier, exportedItem] of exportItems) {
-                        if (shouldIgnore(exportedItem.jsDocTags))
+                        if (isAlwaysIgnored(exportedItem.jsDocTags))
                             continue;
-                        const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
+                        const isInternalProd = options.isProduction && exportedItem.jsDocTags.has(INTERNAL_TAG);
+                        const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags) || isInternalProd;
                         if (importsForExport) {
                             const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
                                 includeEntryExports: isIncludeEntryExports,
@@ -64,7 +66,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             if (isIgnored &&
                                 (isReferenced || isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports))) {
                                 for (const tagName of exportedItem.jsDocTags) {
-                                    if (options.tags[1].includes(tagName)) {
+                                    if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                     }
                                 }
@@ -171,7 +173,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 if (file.imports?.external) {
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
-                        const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(ws, packageName);
+                        const isHandled = packageName &&
+                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly);
                         if (!isHandled)
                             collector.addIssue({
                                 type: 'unlisted',

package/dist/graph/build.js

@@ -5,6 +5,7 @@ import { partition } from '../util/array.js';
 import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { existsSync } from 'node:fs';
+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';
@@ -57,7 +58,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const dependencies = deputy.getDependencies(name);
         const baseConfig = chief.getConfigForWorkspace(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, fileNames } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames, include, exclude } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
             name,
@@ -249,6 +250,19 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     principal.addProjectPath(filePath);
                 }
             }
+            if (extensions.length > 0) {
+                const extPart = extensions.length === 1 ? extensions[0] : `.{${extensions.map(ext => ext.slice(1)).join(',')}}`;
+                const bases = include ? new Set(include.map(p => picomatch.scan(p).base || dir)) : new Set([dir]);
+                const patterns = [
+                    ...Array.from(bases, base => `${base}/**/*${extPart}`),
+                    ...(exclude?.map(p => `!${p}`) ?? []),
+                ];
+                const compilerPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'compiler extension paths' });
+                for (const compilerPath of compilerPaths) {
+                    if (!isIgnoredWorkspace(compilerPath))
+                        principal.addProjectPath(compilerPath);
+                }
+            }
         }
         else {
             const patterns = options.isProduction

package/dist/manifest/helpers.js

@@ -1,17 +1,48 @@
-import { join } from '../util/path.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from '../util/path.js';
 import { _require } from '../util/require.js';
+const monorepoRootCache = new Map();
+const findMonorepoRootAbove = (startDir) => {
+    if (monorepoRootCache.has(startDir))
+        return monorepoRootCache.get(startDir);
+    let current = dirname(startDir);
+    let result;
+    while (current !== dirname(current)) {
+        if (existsSync(join(current, 'pnpm-workspace.yaml'))) {
+            result = current;
+            break;
+        }
+        try {
+            const pkg = JSON.parse(readFileSync(join(current, 'package.json'), 'utf8'));
+            if (pkg.workspaces) {
+                result = current;
+                break;
+            }
+        }
+        catch { }
+        current = dirname(current);
+    }
+    monorepoRootCache.set(startDir, result);
+    return result;
+};
 export const loadPackageManifest = ({ dir, packageName, cwd }) => {
     try {
         return _require(join(dir, 'node_modules', packageName, 'package.json'));
     }
-    catch (_error) {
-        if (dir !== cwd) {
-            try {
-                return _require(join(cwd, 'node_modules', packageName, 'package.json'));
-            }
-            catch (_error) {
-            }
+    catch { }
+    if (dir !== cwd) {
+        try {
+            return _require(join(cwd, 'node_modules', packageName, 'package.json'));
+        }
+        catch { }
+        return;
+    }
+    const root = findMonorepoRootAbove(cwd);
+    if (root) {
+        try {
+            return _require(join(root, 'node_modules', packageName, 'package.json'));
         }
+        catch { }
     }
 };
 export const getFilteredScripts = (scripts) => {

package/dist/plugins/typescript/index.js

@@ -32,7 +32,8 @@ const resolveConfig = async (localConfig, options) => {
     return compact([
         ...extend,
         ...references,
-        ...[...types, ...plugins, ...importHelpers].map(id => toDeferResolve(id)),
+        ...types.map(id => toDeferResolve(id, { isTypeOnly: true })),
+        ...[...plugins, ...importHelpers].map(id => toDeferResolve(id)),
         ...jsx,
         ...aliases,
     ]);

package/dist/reporters/symbols.js

@@ -1,7 +1,7 @@
-import { printConfigurationHints } from './util/configuration-hints.js';
+import { printConfigurationHints, printTagHints } from './util/configuration-hints.js';
 import { dim, flattenIssues, getColoredTitle, getIssueTypeTitle, getTableForType } from './util/util.js';
 export default (options) => {
-    const { report, issues, isDisableConfigHints, isShowProgress } = options;
+    const { report, issues, isDisableConfigHints, isDisableTagHints, isShowProgress } = options;
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
@@ -24,6 +24,9 @@ export default (options) => {
     if (!isDisableConfigHints) {
         printConfigurationHints(options);
     }
+    if (!isDisableTagHints) {
+        printTagHints(options);
+    }
     if (totalIssues === 0 &&
         isShowProgress &&
         (!options.isTreatConfigHintsAsErrors || options.configurationHints.length === 0)) {

package/dist/reporters/util/configuration-hints.d.ts

@@ -19,4 +19,5 @@ export declare const finalizeConfigurationHints: (results: Results, options: {
     configFilePath?: string;
 }) => ProcessedHint[];
 export declare const printConfigurationHints: ({ cwd, counters, issues, tagHints, configurationHints, enabledPlugins, isTreatConfigHintsAsErrors, includedWorkspaceDirs, selectedWorkspaces, configFilePath, }: ReporterOptions) => void;
+export declare const printTagHints: ({ cwd, tagHints }: ReporterOptions) => void;
 export {};

package/dist/reporters/util/configuration-hints.js

@@ -127,6 +127,8 @@ export const printConfigurationHints = ({ cwd, counters, issues, tagHints, confi
         console.log(getTitle('Configuration hints', configurationHints.length));
         console.warn(getTableForHints(rows).toString());
     }
+};
+export const printTagHints = ({ cwd, tagHints }) => {
     if (tagHints.size > 0) {
         console.log(getDimmedTitle('Tag hints', tagHints.size));
         for (const hint of tagHints) {

package/dist/types/issues.d.ts

@@ -54,6 +54,7 @@ export type ReporterOptions = {
     configurationHints: ConfigurationHint[];
     enabledPlugins: Record<string, string[]>;
     isDisableConfigHints: boolean;
+    isDisableTagHints: boolean;
     isTreatConfigHintsAsErrors: boolean;
     cwd: string;
     isProduction: boolean;

package/dist/types/package-json.d.ts

@@ -53,6 +53,7 @@ export type PackageJson = {
     catalog?: Catalog;
     catalogs?: Catalogs;
     packageManager?: string;
+    engines?: Record<string, string>;
     pnpm?: {
         overrides?: Dependencies;
     };

package/dist/types/workspace.d.ts

@@ -10,6 +10,7 @@ type WorkspaceManifest = {
     optionalPeerDependencies: DependencySet;
     requiredPeerDependencies: DependencyArray;
     allDependencies: DependencySet;
+    engines: Record<string, string>;
     ignoreDependencies: (string | RegExp)[];
     ignoreBinaries: (string | RegExp)[];
     ignoreUnresolved: (string | RegExp)[];

package/dist/typescript/get-imports-and-exports.js

@@ -11,6 +11,7 @@ import { buildJSDocTagLookup } from './visitors/jsdoc.js';
 import { walkAST } from './visitors/walk.js';
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {
     const skipExports = skipExportsForFile || !options.isReportExports;
+    const isDts = filePath.endsWith('.d.ts') || filePath.endsWith('.d.cts') || filePath.endsWith('.d.mts');
     const internal = new Map();
     const external = new Set();
     const unresolved = new Set();
@@ -53,7 +54,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             pos: opts.pos,
             line: opts.line,
             col: opts.col,
-            isTypeOnly: !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
+            isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
         });
         const file = internal.get(importFilePath);
         const importMaps = file ?? createImports();
@@ -129,7 +130,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                         pos: ePos,
                         line,
                         col,
-                        isTypeOnly: !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
+                        isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                     });
                 }
             }
@@ -153,7 +154,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                     pos: uPos,
                     line,
                     col,
-                    isTypeOnly: !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
+                    isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                 });
             }
         }

package/dist/util/create-input-handler.js

@@ -53,7 +53,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
-            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input));
+            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input), input.isTypeOnly);
             if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }

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

@@ -18,6 +18,7 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
     isCache: boolean;
     isDebug: boolean;
     isDisableConfigHints: boolean;
+    isDisableTagHints: boolean;
     isFix: boolean;
     isFixCatalog: boolean;
     isFixDependencies: boolean;

package/dist/util/create-options.js

@@ -107,6 +107,7 @@ export const createOptions = async (options) => {
         isCache: args.cache ?? false,
         isDebug,
         isDisableConfigHints: args['no-config-hints'] || isProduction || Boolean(workspace),
+        isDisableTagHints: Boolean(args['no-config-hints']),
         isFix: args.fix ?? options.isFix ?? isFixFiles ?? fixTypes.length > 0,
         isFixCatalog: fixTypes.length === 0 || fixTypes.includes('catalog'),
         isFixDependencies: fixTypes.length === 0 || fixTypes.includes('dependencies'),

package/dist/util/input.d.ts

@@ -6,6 +6,7 @@ export interface Input {
     specifier: string;
     production?: boolean;
     optional?: boolean;
+    isTypeOnly?: boolean;
     dir?: string;
     containingFilePath?: string;
     allowIncludeExports?: boolean;
@@ -27,6 +28,7 @@ interface IgnoreInput extends Input {
 }
 type Options = {
     optional?: boolean;
+    isTypeOnly?: boolean;
     dir?: string;
     containingFilePath?: string;
     allowIncludeExports?: boolean;

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

@@ -1,6 +1,10 @@
 import type { CompilerOptions } from '../types/project.ts';
-export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<{
+interface TSConfigInfo {
     isFile: boolean;
     compilerOptions: CompilerOptions;
     fileNames: string[];
-}>;
+    include: string[] | undefined;
+    exclude: string[] | undefined;
+}
+export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<TSConfigInfo>;
+export {};

package/dist/util/load-tsconfig.js

@@ -73,42 +73,39 @@ const fillFromReferences = (target, references, dir, visited) => {
             fillFromReferences(target, refConfig.references, refDir, visited);
     }
 };
+const EMPTY = {
+    compilerOptions: {},
+    fileNames: [],
+    include: undefined,
+    exclude: undefined,
+};
 export const loadTSConfig = async (tsConfigFilePath) => {
-    if (isFile(tsConfigFilePath)) {
-        try {
-            const config = parseTsconfig(tsConfigFilePath);
-            const dir = dirname(tsConfigFilePath);
-            const compilerOptions = (config.compilerOptions ?? {});
-            if (compilerOptions.outDir)
-                compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
-            if (compilerOptions.rootDir)
-                compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
-            if (compilerOptions.paths) {
-                compilerOptions.pathsBasePath ??= dir;
-            }
-            if (compilerOptions.rootDirs) {
-                compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => (isAbsolute(d) ? d : join(dir, d)));
-            }
-            if ((!compilerOptions.outDir || !compilerOptions.rootDir) && config.references?.length) {
-                fillFromReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]));
-            }
-            const include = resolvePatterns(config.include, dir, true);
-            const exclude = resolvePatterns(config.exclude, dir, true);
-            const files = resolvePatterns(config.files, dir);
-            const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
-            return { isFile: true, compilerOptions, fileNames };
+    if (!isFile(tsConfigFilePath))
+        return { isFile: false, ...EMPTY };
+    try {
+        const config = parseTsconfig(tsConfigFilePath);
+        const dir = dirname(tsConfigFilePath);
+        const compilerOptions = (config.compilerOptions ?? {});
+        if (compilerOptions.outDir)
+            compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
+        if (compilerOptions.rootDir)
+            compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
+        if (compilerOptions.paths) {
+            compilerOptions.pathsBasePath ??= dir;
+        }
+        if (compilerOptions.rootDirs) {
+            compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => (isAbsolute(d) ? d : join(dir, d)));
         }
-        catch {
-            return {
-                isFile: true,
-                compilerOptions: {},
-                fileNames: [],
-            };
+        if ((!compilerOptions.outDir || !compilerOptions.rootDir) && config.references?.length) {
+            fillFromReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]));
         }
+        const include = resolvePatterns(config.include, dir, true);
+        const exclude = resolvePatterns(config.exclude, dir, true);
+        const files = resolvePatterns(config.files, dir);
+        const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+        return { isFile: true, compilerOptions, fileNames, include, exclude };
+    }
+    catch {
+        return { isFile: true, ...EMPTY };
     }
-    return {
-        isFile: false,
-        compilerOptions: {},
-        fileNames: [],
-    };
 };

package/dist/util/tag.d.ts

@@ -1,5 +1,6 @@
 import type { Tags } from '../types/options.ts';
 export declare const splitTags: (rawTags: string[]) => Tags;
 export declare const shouldIgnore: (jsDocTags: Set<string>, tags: Tags) => boolean;
+export declare const isAlwaysIgnored: (jsDocTags: Set<string>) => boolean;
 export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => boolean;
 export declare const getShouldIgnoreTagHandler: (tags: Tags) => (jsDocTags: Set<string>) => boolean;

package/dist/util/tag.js

@@ -17,8 +17,6 @@ export const shouldIgnore = (jsDocTags, tags) => {
         return true;
     return false;
 };
-export const getShouldIgnoreHandler = (isProduction) => (jsDocTags) => jsDocTags.has(PUBLIC_TAG) ||
-    jsDocTags.has(BETA_TAG) ||
-    jsDocTags.has(ALIAS_TAG) ||
-    (isProduction && jsDocTags.has(INTERNAL_TAG));
+export const isAlwaysIgnored = (jsDocTags) => jsDocTags.has(PUBLIC_TAG) || jsDocTags.has(BETA_TAG) || jsDocTags.has(ALIAS_TAG);
+export const getShouldIgnoreHandler = (isProduction) => (jsDocTags) => isAlwaysIgnored(jsDocTags) || (isProduction && jsDocTags.has(INTERNAL_TAG));
 export const getShouldIgnoreTagHandler = (tags) => (jsDocTags) => shouldIgnore(jsDocTags, tags);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.9.0";
+export declare const version = "6.11.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.9.0';
+export const version = '6.11.0';

package/package.json

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