knip 3.5.0 → 3.6.0

package/dist/ConfigurationChief.js

@@ -17,6 +17,7 @@ import { _load } from './util/loader.js';
 import { getKeysByValue } from './util/object.js';
 import { join, relative, toPosix } from './util/path.js';
 import { normalizePluginConfig, toCamelCase } from './util/plugin.js';
+import { toRegexOrString } from './util/regex.js';
 import { _require } from './util/require.js';
 import { unwrapFunction } from './util/unwrap-function.js';
 import { byPathDepth } from './util/workspace.js';
@@ -131,9 +132,9 @@ export class ConfigurationChief {
         const include = rawConfig.include ?? defaultConfig.include;
         const exclude = rawConfig.exclude ?? defaultConfig.exclude;
         const ignore = arrayify(rawConfig.ignore ?? defaultConfig.ignore);
-        const ignoreBinaries = rawConfig.ignoreBinaries ?? [];
+        const ignoreBinaries = (rawConfig.ignoreBinaries ?? []).map(toRegexOrString);
+        const ignoreDependencies = (rawConfig.ignoreDependencies ?? []).map(toRegexOrString);
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
-        const ignoreDependencies = rawConfig.ignoreDependencies ?? [];
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
         const { syncCompilers, asyncCompilers } = rawConfig;

package/dist/ConfigurationValidator.d.ts

@@ -19,9 +19,9 @@ export declare const ConfigurationValidator: z.ZodObject<{
     project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     paths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
     ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
-    ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
+    ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
     ignoreExportsUsedInFile: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodUnion<[z.ZodLiteral<"class">, z.ZodLiteral<"enum">, z.ZodLiteral<"function">, z.ZodLiteral<"interface">, z.ZodLiteral<"member">, z.ZodLiteral<"type">]>, z.ZodBoolean>]>>;
-    ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     ignoreWorkspaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     includeEntryExports: z.ZodOptional<z.ZodBoolean>;
     compilers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodString>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodString>>]>>>;
@@ -33,8 +33,8 @@ export declare const ConfigurationValidator: z.ZodObject<{
         project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         paths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
         ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
-        ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ignoreBinaries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
+        ignoreDependencies: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">>;
         includeEntryExports: z.ZodOptional<z.ZodBoolean>;
         astro: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -613,8 +613,8 @@ export declare const ConfigurationValidator: z.ZodObject<{
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
         ignore?: string | string[] | undefined;
-        ignoreBinaries?: string[] | undefined;
-        ignoreDependencies?: string[] | undefined;
+        ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreDependencies?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -841,8 +841,8 @@ export declare const ConfigurationValidator: z.ZodObject<{
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
         ignore?: string | string[] | undefined;
-        ignoreBinaries?: string[] | undefined;
-        ignoreDependencies?: string[] | undefined;
+        ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreDependencies?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -1644,9 +1644,9 @@ export declare const ConfigurationValidator: z.ZodObject<{
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
     ignore?: string | string[] | undefined;
-    ignoreBinaries?: string[] | undefined;
+    ignoreBinaries?: (string | RegExp)[] | undefined;
+    ignoreDependencies?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
-    ignoreDependencies?: string[] | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, ((args_0: string, ...args_1: unknown[]) => string) | ((args_0: string, ...args_1: unknown[]) => Promise<string>)> | undefined;
@@ -1658,8 +1658,8 @@ export declare const ConfigurationValidator: z.ZodObject<{
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
         ignore?: string | string[] | undefined;
-        ignoreBinaries?: string[] | undefined;
-        ignoreDependencies?: string[] | undefined;
+        ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreDependencies?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -2109,9 +2109,9 @@ export declare const ConfigurationValidator: z.ZodObject<{
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
     ignore?: string | string[] | undefined;
-    ignoreBinaries?: string[] | undefined;
+    ignoreBinaries?: (string | RegExp)[] | undefined;
+    ignoreDependencies?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
-    ignoreDependencies?: string[] | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, ((args_0: string, ...args_1: unknown[]) => string) | ((args_0: string, ...args_1: unknown[]) => Promise<string>)> | undefined;
@@ -2123,8 +2123,8 @@ export declare const ConfigurationValidator: z.ZodObject<{
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
         ignore?: string | string[] | undefined;
-        ignoreBinaries?: string[] | undefined;
-        ignoreDependencies?: string[] | undefined;
+        ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreDependencies?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
         astro?: string | boolean | string[] | {
             config?: string | string[] | undefined;

package/dist/ConfigurationValidator.js

@@ -5,6 +5,7 @@ const syncCompilerSchema = z.function().args(z.string()).returns(z.string());
 const asyncCompilerSchema = z.function().args(z.string()).returns(z.promise(z.string()));
 const compilerSchema = z.union([syncCompilerSchema, asyncCompilerSchema]);
 const compilersSchema = z.record(z.string(), compilerSchema);
+const stringOrRegexSchema = z.array(z.union([z.string(), z.instanceof(RegExp)]));
 const issueTypeSchema = z.union([
     z.literal('files'),
     z.literal('dependencies'),
@@ -38,9 +39,9 @@ const rootConfigurationSchema = z.object({
     project: globSchema.optional(),
     paths: pathsSchema.optional(),
     ignore: globSchema.optional(),
-    ignoreBinaries: z.array(z.string()).optional(),
+    ignoreBinaries: stringOrRegexSchema.optional(),
+    ignoreDependencies: stringOrRegexSchema.optional(),
     ignoreExportsUsedInFile: ignoreExportsUsedInFileSchema.optional(),
-    ignoreDependencies: z.array(z.string()).optional(),
     ignoreWorkspaces: z.array(z.string()).optional(),
     includeEntryExports: z.boolean().optional(),
     compilers: compilersSchema.optional(),
@@ -111,8 +112,8 @@ const baseWorkspaceConfigurationSchema = z.object({
     project: globSchema.optional(),
     paths: pathsSchema.optional(),
     ignore: globSchema.optional(),
-    ignoreBinaries: z.array(z.string()).optional(),
-    ignoreDependencies: z.array(z.string()).optional(),
+    ignoreBinaries: stringOrRegexSchema.optional(),
+    ignoreDependencies: stringOrRegexSchema.optional(),
     includeEntryExports: z.boolean().optional(),
 });
 const workspaceConfigurationSchema = baseWorkspaceConfigurationSchema.merge(pluginsSchema.partial());

package/dist/DependencyDeputy.d.ts

@@ -4,9 +4,11 @@ import type { ConfigurationHints, Issue } from './types/issues.js';
 import type { WorkspaceManifests, HostDependencies, InstalledBinaries } from './types/workspace.js';
 import type { PackageJson } from '@npmcli/package-json';
 type Options = {
+    isProduction: boolean;
     isStrict: boolean;
 };
 export declare class DependencyDeputy {
+    isProduction: boolean;
     isStrict: boolean;
     _manifests: WorkspaceManifests;
     referencedDependencies: Map<string, Set<string>>;
@@ -14,18 +16,18 @@ export declare class DependencyDeputy {
     hostDependencies: Map<string, HostDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
-    ignoreBinaries: string[];
-    ignoreDependencies: string[];
-    constructor({ isStrict }: Options);
+    ignoreBinaries: (string | RegExp)[];
+    ignoreDependencies: (string | RegExp)[];
+    constructor({ isProduction, isStrict }: Options);
     addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }: {
         name: string;
         dir: string;
         manifestPath: string;
         manifest: PackageJson;
-        ignoreDependencies: string[];
-        ignoreBinaries: string[];
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
     }): void;
-    addIgnored(ignoreBinaries: string[], ignoreDependencies: string[]): void;
+    addIgnored(ignoreBinaries: (string | RegExp)[], ignoreDependencies: (string | RegExp)[]): void;
     getWorkspaceManifest(workspaceName: string): {
         workspaceDir: string;
         manifestPath: string;
@@ -36,8 +38,8 @@ export declare class DependencyDeputy {
         optionalDependencies: string[];
         devDependencies: string[];
         allDependencies: string[];
-        ignoreDependencies: string[];
-        ignoreBinaries: string[];
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
     } | undefined;
     getProductionDependencies(workspaceName: string): string[];
     getDevDependencies(workspaceName: string): string[];

package/dist/DependencyDeputy.js

@@ -1,7 +1,9 @@
 import { isBuiltin } from 'node:module';
 import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
+import { hasMatch, hasMatchInArray, hasMatchInSet } from './util/regex.js';
 export class DependencyDeputy {
+    isProduction;
     isStrict;
     _manifests = new Map();
     referencedDependencies;
@@ -11,7 +13,8 @@ export class DependencyDeputy {
     hasTypesIncluded;
     ignoreBinaries = [];
     ignoreDependencies = [];
-    constructor({ isStrict }) {
+    constructor({ isProduction, isStrict }) {
+        this.isProduction = isProduction;
         this.isStrict = isStrict;
         this.referencedDependencies = new Map();
         this.referencedBinaries = new Map();
@@ -122,9 +125,9 @@ export class DependencyDeputy {
         else {
             this.addReferencedDependency(workspace.name, packageName);
         }
-        if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))
+        if (hasMatch(this.getWorkspaceManifest(workspace.name)?.ignoreDependencies, packageName))
             return true;
-        if (this.ignoreDependencies.includes(packageName))
+        if (hasMatch(this.ignoreDependencies, packageName))
             return true;
         return false;
     }
@@ -143,9 +146,9 @@ export class DependencyDeputy {
                 }
             }
         }
-        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
+        if (hasMatch(this.getWorkspaceManifest(workspace.name)?.ignoreBinaries, binaryName))
             return true;
-        if (this.ignoreBinaries.includes(binaryName))
+        if (hasMatch(this.ignoreBinaries, binaryName))
             return true;
         return false;
     }
@@ -166,12 +169,14 @@ export class DependencyDeputy {
             const hasTypesIncluded = this.getHasTypesIncluded(workspaceName);
             const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...this.ignoreBinaries, ...ignoreBinaries];
             const ignoreDeps = [...IGNORED_DEPENDENCIES, ...this.ignoreDependencies, ...ignoreDependencies];
-            const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
+            const isNotIgnoredDependency = (packageName) => !hasMatch(ignoreDeps, packageName);
             const isNotIgnoredBinary = (packageName) => {
                 if (installedBinaries?.has(packageName)) {
                     const binaryNames = installedBinaries.get(packageName);
                     if (binaryNames) {
-                        if (ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
+                        if (ignoreBins.some(binaryName => typeof binaryName === 'string'
+                            ? binaryNames.has(binaryName)
+                            : [...binaryNames].some(n => binaryName.test(n))))
                             return false;
                     }
                 }
@@ -225,30 +230,56 @@ export class DependencyDeputy {
     }
     getConfigurationHints() {
         const configurationHints = new Set();
-        const rootIgnoreBinaries = Object.fromEntries(this.ignoreBinaries.map(key => [key, 0]));
-        const rootIgnoreDependencies = Object.fromEntries(this.ignoreDependencies.map(key => [key, 0]));
+        const rootIgnoreBinaries = new Map(this.ignoreBinaries.map(key => [key, 0]));
+        const rootIgnoreDependencies = new Map(this.ignoreDependencies.map(key => [key, 0]));
         for (const [workspaceName, { ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
             const referencedBinaries = this.referencedBinaries.get(workspaceName);
             const installedBinaries = this.getInstalledBinaries(workspaceName);
-            referencedDependencies?.forEach(pkg => pkg in rootIgnoreDependencies && rootIgnoreDependencies[pkg]++);
-            referencedBinaries?.forEach(binaryName => binaryName in rootIgnoreBinaries && rootIgnoreBinaries[binaryName]++);
+            referencedDependencies?.forEach(pkg => {
+                for (const key of rootIgnoreDependencies.keys()) {
+                    if ((typeof key === 'string' && key === pkg) || (key instanceof RegExp && key.test(pkg))) {
+                        rootIgnoreDependencies.set(key, rootIgnoreDependencies.get(key) + 1);
+                        return;
+                    }
+                }
+            });
+            referencedBinaries?.forEach(binaryName => {
+                for (const key of rootIgnoreBinaries.keys()) {
+                    if ((typeof key === 'string' && key === binaryName) || (key instanceof RegExp && key.test(binaryName))) {
+                        rootIgnoreBinaries.set(key, rootIgnoreBinaries.get(key) + 1);
+                        return;
+                    }
+                }
+            });
             const dependencies = [
                 ...this.getProductionDependencies(workspaceName),
                 ...this.getDevDependencies(workspaceName),
             ];
             const peerDependencies = this.getPeerDependencies(workspaceName);
-            const isReferencedDep = (name) => referencedDependencies?.has(name) && dependencies.includes(name);
-            const isReferencedBin = (name) => referencedBinaries?.has(name) && installedBinaries?.has(name);
             ignoreDependencies
-                .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) ||
-                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreDependencies.includes(packageName)) ||
-                (!peerDependencies.includes(packageName) && isReferencedDep(packageName)))
-                .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' }));
+                .filter(packageName => {
+                if (hasMatchInArray(IGNORED_DEPENDENCIES, packageName))
+                    return true;
+                if (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreDependencies.includes(packageName))
+                    return true;
+                const isReferenced = hasMatchInSet(referencedDependencies, packageName);
+                const isListed = hasMatchInArray(dependencies, packageName) && !hasMatchInArray(peerDependencies, packageName);
+                return isListed && isReferenced;
+            })
+                .forEach(identifier => {
+                configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' });
+            });
             ignoreBinaries
-                .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) ||
-                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreBinaries.includes(binaryName)) ||
-                isReferencedBin(binaryName))
+                .filter(binaryName => {
+                if (hasMatchInArray(IGNORED_GLOBAL_BINARIES, binaryName))
+                    return true;
+                if (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreBinaries.includes(binaryName))
+                    return true;
+                const isReferenced = hasMatchInSet(referencedBinaries, binaryName);
+                const isInstalled = hasMatchInArray(Array.from(installedBinaries?.keys() ?? []), binaryName);
+                return isReferenced && isInstalled;
+            })
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
         const installedBinaries = this.getInstalledBinaries(ROOT_WORKSPACE_NAME);
@@ -257,12 +288,23 @@ export class DependencyDeputy {
             ...this.getDevDependencies(ROOT_WORKSPACE_NAME),
         ];
         const peerDependencies = this.getPeerDependencies(ROOT_WORKSPACE_NAME);
-        Object.keys(rootIgnoreBinaries)
-            .filter(key => IGNORED_GLOBAL_BINARIES.includes(key) || (rootIgnoreBinaries[key] !== 0 && installedBinaries?.has(key)))
+        Array.from(rootIgnoreBinaries.keys())
+            .filter(binaryName => {
+            if (hasMatchInArray(IGNORED_GLOBAL_BINARIES, binaryName))
+                return true;
+            const isReferenced = rootIgnoreBinaries.get(binaryName) !== 0;
+            const isInstalled = hasMatchInArray(Array.from(installedBinaries?.keys() ?? []), binaryName);
+            return (isReferenced && isInstalled) || (!this.isProduction && !isReferenced && !isInstalled);
+        })
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreBinaries' }));
-        Object.keys(rootIgnoreDependencies)
-            .filter(key => IGNORED_DEPENDENCIES.includes(key) ||
-            (rootIgnoreDependencies[key] === 0 && !peerDependencies.includes(key) && !dependencies.includes(key)))
+        Array.from(rootIgnoreDependencies.keys())
+            .filter(packageName => {
+            if (hasMatchInArray(IGNORED_DEPENDENCIES, packageName))
+                return true;
+            const isReferenced = rootIgnoreDependencies.get(packageName) !== 0;
+            const isListed = hasMatchInArray(dependencies, packageName) && !hasMatchInArray(peerDependencies, packageName);
+            return (isReferenced && isListed) || (!this.isProduction && !isReferenced && !isListed);
+        })
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
         return { configurationHints };
     }

package/dist/IssueCollector.js

@@ -1,9 +1,6 @@
 import { initIssues, initCounters } from './issues/initializers.js';
 import { relative } from './util/path.js';
-function objectInSet(set, obj) {
-    const objJSON = JSON.stringify(obj);
-    return Array.from(set).some(item => JSON.stringify(item) === objJSON);
-}
+const hasHint = (hints, hint) => Array.from(hints).some(item => item.identifier === hint.identifier && item.type === hint.type && item.workspaceName === hint.workspaceName);
 export class IssueCollector {
     cwd;
     rules;
@@ -44,7 +41,7 @@ export class IssueCollector {
         }
     }
     addConfigurationHint(issue) {
-        if (!objectInSet(this.configurationHints, issue)) {
+        if (!hasHint(this.configurationHints, issue)) {
             this.configurationHints.add(issue);
         }
     }

package/dist/ProjectPrincipal.js

@@ -7,7 +7,8 @@ import { getImportsAndExports } from './typescript/getImportsAndExports.js';
 import { createCustomModuleResolver } from './typescript/resolveModuleNames.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { compact } from './util/array.js';
-import { isMaybePackageName, sanitizeSpecifier } from './util/modules.js';
+import { debugLog } from './util/debug.js';
+import { isStartsLikePackageName, sanitizeSpecifier } from './util/modules.js';
 import { dirname, extname, isInNodeModules, join } from './util/path.js';
 import { timerify } from './util/Performance.js';
 const baseCompilerOptions = {
@@ -145,7 +146,7 @@ export class ProjectPrincipal {
             }
             else {
                 const sanitizedSpecifier = sanitizeSpecifier(specifier);
-                if (isMaybePackageName(sanitizedSpecifier)) {
+                if (isStartsLikePackageName(sanitizedSpecifier)) {
                     external.add(sanitizedSpecifier);
                 }
                 else {
@@ -210,7 +211,8 @@ export class ProjectPrincipal {
         try {
             return this.backend.lsFindReferences(filePath, pos) ?? [];
         }
-        catch {
+        catch (error) {
+            debugLog('*', String(error));
             return [];
         }
     }

package/dist/WorkspaceWorker.js

@@ -4,7 +4,7 @@ import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
 import { FAKE_PATH } from './util/loader.js';
 import { get, getKeysByValue } from './util/object.js';
-import { join, toPosix } from './util/path.js';
+import { basename, join, toPosix } from './util/path.js';
 import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
 const nullConfig = { config: null, entry: null, project: null };
 export class WorkspaceWorker {
@@ -183,7 +183,7 @@ export class WorkspaceWorker {
                         continue;
                     const patterns = this.getConfigurationFilePatterns(pluginName);
                     const allConfigFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
-                    const configFilePaths = allConfigFilePaths.filter(filePath => !filePath.endsWith('package.json') ||
+                    const configFilePaths = allConfigFilePaths.filter(filePath => basename(filePath) !== 'package.json' ||
                         get(this.manifest, 'PACKAGE_JSON_PATH' in plugin ? plugin.PACKAGE_JSON_PATH : pluginName));
                     debugLogArray([name, plugin.NAME], 'config file paths', configFilePaths);
                     if (configFilePaths.length === 0)

package/dist/constants.js

@@ -33,6 +33,7 @@ export const IGNORED_GLOBAL_BINARIES = [
     'test',
     'true',
     'yarn',
+    'xargs',
 ];
 export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
 export const DUMMY_VIRTUAL_FILE_EXTENSIONS = new Set(['.html', '.jpeg', '.jpg', '.png', '.svg', '.webp']);

package/dist/index.js

@@ -19,7 +19,7 @@ export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress, isIncludeEntryExports, isIsolateWorkspaces, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
     const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports });
-    const deputy = new DependencyDeputy({ isStrict });
+    const deputy = new DependencyDeputy({ isProduction, isStrict });
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
     const isGitIgnored = gitignore ? isGitIgnoredSync({ cwd }) : () => false;
@@ -214,15 +214,14 @@ export const main = async (unresolvedConfiguration) => {
                     }
                     else {
                         const importedModule = importedSymbols.get(specifierFilePath);
-                        for (const identifier of importItems.symbols) {
+                        for (const identifier of importItems.symbols)
                             importedModule.symbols.add(identifier);
-                        }
+                        if (importItems.hasStar)
+                            importedModule.hasStar = true;
                         if (importItems.isReExport) {
-                            importedModule.isReExport = importItems.isReExport;
+                            importedModule.isReExport = true;
                             importedModule.isReExportedBy.add(filePath);
                         }
-                        if (importItems.isStar)
-                            importedModule.isStar = importItems.isStar;
                     }
                 }
                 duplicate.forEach(symbols => {
@@ -299,16 +298,17 @@ export const main = async (unresolvedConfiguration) => {
             const workspace = chief.findWorkspaceByFilePath(filePath);
             const principal = workspace && factory.getPrincipalByPackageName(workspace.pkgName);
             if (principal) {
-                if (!workspace.config.isIncludeEntryExports && principal.entryPaths.has(filePath))
+                const { isIncludeEntryExports } = workspace.config;
+                if (!isIncludeEntryExports && principal.entryPaths.has(filePath))
                     continue;
-                const importingModule = importedSymbols.get(filePath);
+                const importsForExport = importedSymbols.get(filePath);
                 for (const [symbol, exportedItem] of exportItems.entries()) {
                     if (exportedItem.jsDocTags.has('@public') || exportedItem.jsDocTags.has('@beta'))
                         continue;
                     if (isProduction && exportedItem.jsDocTags.has('@internal'))
                         continue;
-                    if (importingModule && isSymbolImported(symbol, importingModule)) {
-                        if (importingModule.isReExport && isExportedInEntryFile(principal, importingModule))
+                    if (importsForExport && isSymbolImported(symbol, importsForExport)) {
+                        if (importsForExport.isReExport && isExportedInEntryFile(principal, importsForExport))
                             continue;
                         if (report.enumMembers && exportedItem.type === 'enum' && exportedItem.members) {
                             principal.findUnusedMembers(filePath, exportedItem.members).forEach(member => {
@@ -334,28 +334,20 @@ export const main = async (unresolvedConfiguration) => {
                         }
                         continue;
                     }
-                    const isStar = Boolean(importingModule?.isStar);
-                    const isReExportedByEntryFile = !workspace.config.isIncludeEntryExports && isStar && isExportedInEntryFile(principal, importingModule);
-                    if (!isReExportedByEntryFile && !isExportedItemReferenced(principal, exportedItem, filePath)) {
-                        if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
-                            const type = isStar ? 'nsTypes' : 'types';
-                            collector.addIssue({
-                                type,
-                                filePath,
-                                symbol,
-                                symbolType: exportedItem.type,
-                                ...principal.getPos(exportedItem.node, exportedItem.pos),
-                            });
-                        }
-                        else {
-                            const type = isStar ? 'nsExports' : 'exports';
-                            collector.addIssue({
-                                type,
-                                filePath,
-                                symbol,
-                                ...principal.getPos(exportedItem.node, exportedItem.pos),
-                            });
-                        }
+                    const hasNsImport = Boolean(importsForExport?.hasStar);
+                    const isReExport = !isIncludeEntryExports && hasNsImport && isExportedInEntryFile(principal, importsForExport);
+                    const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
+                    if (hasNsImport && ((!report.nsTypes && isType) || (!report.nsExports && !isType)))
+                        continue;
+                    if (!isReExport && !isExportedItemReferenced(principal, exportedItem, filePath)) {
+                        const type = isType ? (hasNsImport ? 'nsTypes' : 'types') : hasNsImport ? 'nsExports' : 'exports';
+                        collector.addIssue({
+                            type,
+                            filePath,
+                            symbol,
+                            symbolType: exportedItem.type,
+                            ...principal.getPos(exportedItem.node, exportedItem.pos),
+                        });
                     }
                 }
             }

package/dist/plugins/_template/index.js

@@ -1,3 +1,4 @@
+import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
@@ -10,10 +11,7 @@ export const PRODUCTION_ENTRY_FILE_PATTERNS = [];
 export const PROJECT_FILE_PATTERNS = [];
 const findPluginDependencies = async (configFilePath, options) => {
     const { manifest, config, isProduction } = options;
-    const localConfig = configFilePath.endsWith('package.json')
-        ?
-            manifest.plugin
-        : await load(configFilePath);
+    const localConfig = basename(configFilePath) === 'package.json' ? manifest.plugin : await load(configFilePath);
     if (!localConfig)
         return [];
     const entryPatterns = (config?.entry ?? localConfig.entryPathsOrPatterns ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);

package/dist/plugins/astro/index.js

@@ -12,7 +12,7 @@ export const findDependencies = async (configFilePath, options) => {
         : [...ENTRY_FILE_PATTERNS.map(toEntryPattern), ...PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern)];
     if (!isProduction &&
         manifest.scripts &&
-        Object.values(manifest.scripts).some(script => /astro (--.+ )?check/.test(script))) {
+        Object.values(manifest.scripts).some(script => /(?<=^|\s)astro(\s|\s.+\s)check(?=\s|$)/.test(script))) {
         dependencies.push('@astrojs/check');
     }
     return dependencies;

package/dist/plugins/ava/index.js

@@ -1,6 +1,6 @@
-import { _getDependenciesFromScripts } from '../../binaries/index.js';
+import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
+import { getDependenciesFromScripts, hasDependency, load } from '../../util/plugin.js';
 import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Ava';
 export const ENABLERS = ['ava'];
@@ -20,9 +20,7 @@ export const ENTRY_FILE_PATTERNS = [
 ];
 const findAvaDependencies = async (configFilePath, options) => {
     const { cwd, manifest, isProduction, config } = options;
-    let localConfig = configFilePath.endsWith('package.json')
-        ? manifest.ava
-        : await load(configFilePath);
+    let localConfig = basename(configFilePath) === 'package.json' ? manifest.ava : await load(configFilePath);
     if (typeof localConfig === 'function')
         localConfig = localConfig();
     const entryPatterns = (config.entry ?? localConfig?.files ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
@@ -31,7 +29,7 @@ const findAvaDependencies = async (configFilePath, options) => {
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    const dependencies = _getDependenciesFromScripts([fakeCommand], {
+    const dependencies = getDependenciesFromScripts([fakeCommand], {
         cwd,
         manifest,
         knownGlobalsOnly: true,

package/dist/plugins/babel/index.js

@@ -1,4 +1,5 @@
 import { compact } from '../../util/array.js';
+import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 import { resolveName, api } from './helpers.js';
@@ -21,9 +22,7 @@ export const getDependenciesFromConfig = (config) => {
 const findBabelDependencies = async (configFilePath, { manifest, isProduction }) => {
     if (isProduction)
         return [];
-    let localConfig = configFilePath.endsWith('package.json')
-        ? manifest.babel
-        : await load(configFilePath);
+    let localConfig = basename(configFilePath) === 'package.json' ? manifest.babel : await load(configFilePath);
     if (typeof localConfig === 'function')
         localConfig = localConfig(api);
     if (!localConfig)

package/dist/plugins/commitizen/index.js

@@ -1,3 +1,4 @@
+import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'Commitizen';
@@ -8,9 +9,7 @@ export const CONFIG_FILE_PATTERNS = ['.czrc', '.cz.json', 'package.json'];
 const findPluginDependencies = async (configFilePath, { manifest, isProduction }) => {
     if (isProduction)
         return [];
-    const localConfig = configFilePath.endsWith('package.json')
-        ? manifest.config?.commitizen
-        : await load(configFilePath);
+    const localConfig = basename(configFilePath) === 'package.json' ? manifest.config?.commitizen : await load(configFilePath);
     if (!localConfig)
         return [];
     return localConfig.path ? [localConfig.path] : [];

package/dist/plugins/commitlint/index.js

@@ -1,3 +1,4 @@
+import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'commitlint';
@@ -12,9 +13,7 @@ export const CONFIG_FILE_PATTERNS = [
 const findCommitLintDependencies = async (configFilePath, { manifest, isProduction }) => {
     if (isProduction)
         return [];
-    const localConfig = configFilePath.endsWith('package.json')
-        ? manifest.commitlint
-        : await load(configFilePath);
+    const localConfig = basename(configFilePath) === 'package.json' ? manifest.commitlint : await load(configFilePath);
     if (!localConfig)
         return [];
     return localConfig.extends ? [localConfig.extends].flat() : [];