knip 6.10.0 → 6.11.0

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, undefined, extImport.isTypeOnly);
+                        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/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/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/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.10.0";
+export declare const version = "6.11.0";

package/dist/version.js

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

package/package.json

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