knip 5.26.0 → 5.27.0

package/dist/plugins/rspack/index.js

@@ -0,0 +1,22 @@
+import { hasDependency } from '#p/util/plugin.js';
+import { compact } from '../../util/array.js';
+import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+const title = 'Rspack';
+const enablers = ['@rspack/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['rspack.config*.{js,ts,mjs,cjs}'];
+const resolveConfig = async (localConfig, options) => {
+    const { cwd, isProduction } = options;
+    const { entryPatterns, dependencies } = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
+    const deps = Array.from(dependencies).filter(dependency => !dependency.startsWith('builtin:'));
+    if (isProduction)
+        return [...entryPatterns];
+    return compact([...entryPatterns, ...deps]);
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};

package/dist/plugins/vitest/index.js

@@ -47,7 +47,7 @@ const getConfigs = async (localConfig) => {
     return configs;
 };
 export const resolveEntryPaths = async (localConfig, options) => {
-    const dependencies = new Set();
+    const dependencies = new Set(['src/vite-env.d.ts']);
     const configs = await getConfigs(localConfig);
     for (const cfg of configs) {
         const rootDir = cfg.test?.root ?? '.';

package/dist/types/cli.d.ts

@@ -1,20 +1,27 @@
 export interface CommandLineOptions {
+    cacheLocation: string;
     cwd: string;
-    tsConfigFile?: string;
+    excludedIssueTypes: string[];
+    fixTypes: string[];
     gitignore: boolean;
+    includedIssueTypes: string[];
+    isCache: boolean;
     isDebug: boolean;
-    isStrict: boolean;
-    isProduction: boolean;
-    isShowProgress: boolean;
+    isDependenciesShorthand: boolean;
+    isExportsShorthand: boolean;
+    isFilesShorthand: boolean;
+    isFix: boolean;
+    isHideConfigHints: boolean;
     isIncludeEntryExports: boolean;
     isIncludeLibs: boolean;
     isIsolateWorkspaces: boolean;
+    isProduction: boolean;
+    isRemoveFiles: boolean;
+    isShowProgress: boolean;
+    isStrict: boolean;
     isWatch: boolean;
-    isCache?: boolean;
-    cacheLocation?: string;
     tags: Tags;
-    isFix: boolean;
-    fixTypes: string[];
-    isRemoveFiles: boolean;
+    tsConfigFile: string | undefined;
+    workspace: string | undefined;
 }
 export type Tags = [string[], string[]];

package/dist/typescript/{createHosts.js → create-hosts.js}

@@ -3,7 +3,7 @@ import path from 'node:path';
 import ts from 'typescript';
 import { getCompilerExtensions } from '../compilers/index.js';
 import { SourceFileManager } from './SourceFileManager.js';
-import { createCustomModuleResolver } from './resolveModuleNames.js';
+import { createCustomModuleResolver } from './resolve-module-names.js';
 const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }) => {
     const fileManager = new SourceFileManager({ compilers, isSkipLibs });

package/dist/typescript/visitors/dynamic-imports/importCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/importCall.js

@@ -98,22 +98,20 @@ export default visit(() => true, node => {
                         ts.isArrayBindingPattern(variableDeclarationParent.name)) {
                         const index = arrayLiteralExpression.elements.indexOf(node);
                         const element = variableDeclarationParent.name.elements[index];
-                        const isTLA = isTopLevel(variableDeclarationParent.parent);
-                        if (ts.isBindingElement(element) && ts.isObjectBindingPattern(element.name) && element.name.elements) {
-                            return element.name.elements.map(element => {
-                                const identifier = (element.propertyName ?? element.name).getText();
-                                const alias = element.propertyName ? element.name.getText() : undefined;
-                                return { identifier, alias, symbol: isTLA ? element.symbol : undefined, specifier, pos: element.pos };
-                            });
+                        if (element) {
+                            const isTLA = isTopLevel(variableDeclarationParent.parent);
+                            if (ts.isBindingElement(element) && ts.isObjectBindingPattern(element.name) && element.name.elements) {
+                                return element.name.elements.map(element => {
+                                    const identifier = (element.propertyName ?? element.name).getText();
+                                    const alias = element.propertyName ? element.name.getText() : undefined;
+                                    const symbol = isTLA ? element.symbol : undefined;
+                                    return { identifier, alias, symbol, specifier, pos: element.pos };
+                                });
+                            }
+                            const alias = element.name.escapedText;
+                            const symbol = isTLA ? element.symbol : undefined;
+                            return { identifier: 'default', symbol, alias, specifier, pos: element.pos };
                         }
-                        const alias = element.name.escapedText;
-                        return {
-                            identifier: 'default',
-                            symbol: isTLA ? element.symbol : undefined,
-                            alias,
-                            specifier,
-                            pos: element.pos,
-                        };
                     }
                     return { identifier: 'default', specifier, pos: node.arguments[0].pos };
                 }

package/dist/typescript/visitors/dynamic-imports/importType.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/jsDocType.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import type { ImportNode } from '../../../types/imports.js';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | ImportNode | ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | ImportNode | ImportNode[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/propertyAccessCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/requireCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/exports/exportAssignment.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
 export default _default;

package/dist/typescript/visitors/exports/exportDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
 export default _default;

package/dist/typescript/visitors/exports/exportKeyword.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
 export default _default;

package/dist/typescript/visitors/exports/exportsAccessExpression.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
 export default _default;

package/dist/typescript/visitors/exports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[])[];
 export default _default;

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
 export default _default;

package/dist/typescript/visitors/imports/importDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/imports/importEqualsDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/imports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
 export default _default;

package/dist/typescript/visitors/imports/reExportDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
 export default _default;

package/dist/typescript/visitors/index.d.ts

@@ -1,7 +1,7 @@
 import type ts from 'typescript';
 import type { ExportNode } from '../../types/exports.js';
 import type { ImportNode } from '../../types/imports.js';
-import type { GetImportsAndExportsOptions } from '../getImportsAndExports.js';
+import type { GetImportsAndExportsOptions } from '../get-imports-and-exports.js';
 type FileCondition = (sourceFile: ts.SourceFile) => boolean;
 type VisitorFactory<T> = (fileCondition: FileCondition, fn: Visitor<T>) => VisitorCondition<T>;
 type VisitorCondition<T> = (sourceFile: ts.SourceFile) => Visitor<T>;

package/dist/typescript/visitors/scripts/bun.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | string | string[];
 export default _default;

package/dist/typescript/visitors/scripts/execa.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | string | string[];
 export default _default;

package/dist/typescript/visitors/scripts/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | string | string[])[];
 export default _default;

package/dist/typescript/visitors/scripts/zx.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => undefined | string | string[];
 export default _default;

package/dist/util/create-workspace-graph.d.ts

@@ -0,0 +1,8 @@
+import type { PackageJson } from '../types/package-json.js';
+interface Package {
+    manifest: PackageJson;
+    dir: string;
+}
+export type WorkspaceGraph = Record<string, Set<string>>;
+export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, byPkgName: Map<string, Package>, byName: Map<string, Package>): WorkspaceGraph;
+export {};

package/dist/util/{pkgs-graph.js → create-workspace-graph.js}

@@ -1,8 +1,8 @@
 import { join } from './path.js';
 const types = ['peerDependencies', 'devDependencies', 'optionalDependencies', 'dependencies'];
-export function createPkgGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
+export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
     const graph = {};
-    const getPkgDirs = (pkg) => {
+    const getWorkspaceDirs = (pkg) => {
         const dirs = new Set();
         for (const type of types) {
             if (pkg.manifest[type]) {
@@ -20,7 +20,7 @@ export function createPkgGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
     for (const name of wsNames) {
         const pkg = byName.get(name);
         if (pkg)
-            graph[join(cwd, name)] = getPkgDirs(pkg);
+            graph[join(cwd, name)] = getWorkspaceDirs(pkg);
     }
     return graph;
 }

package/dist/util/dependency-graph.d.ts

@@ -1,7 +1,6 @@
-import type { FileNode, IdToFileMap, IdToNsToFileMap, ImportDetails } from '../types/dependency-graph.js';
-export declare const createFileNode: () => FileNode;
+import type { DependencyGraph, FileNode, IdToFileMap, IdToNsToFileMap, ImportDetails, ImportMap } from '../types/dependency-graph.js';
+export declare const getOrCreateFileNode: (graph: DependencyGraph, filePath: string) => FileNode;
+export declare const updateImportMap: (file: FileNode, importMap: ImportMap, graph: DependencyGraph) => void;
 export declare const createImports: () => ImportDetails;
 export declare const addValue: (map: IdToFileMap, id: string, value: string) => void;
 export declare const addNsValue: (map: IdToNsToFileMap, id: string, ns: string, value: string) => void;
-export declare const addValues: (map: IdToFileMap, id: string, values: Set<string>) => void;
-export declare const addNsValues: (map: IdToNsToFileMap, id: string, value: IdToFileMap) => void;

package/dist/util/dependency-graph.js

@@ -1,4 +1,36 @@
-export const createFileNode = () => ({
+export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? createFileNode();
+const updateImportDetails = (importedModule, importItems) => {
+    for (const id of importItems.refs)
+        importedModule.refs.add(id);
+    for (const [id, v] of importItems.imported.entries())
+        addValues(importedModule.imported, id, v);
+    for (const [id, v] of importItems.importedAs.entries())
+        addNsValues(importedModule.importedAs, id, v);
+    for (const [id, v] of importItems.importedNs.entries())
+        addValues(importedModule.importedNs, id, v);
+    for (const [id, v] of importItems.reExported.entries())
+        addValues(importedModule.reExported, id, v);
+    for (const [id, v] of importItems.reExportedAs.entries())
+        addNsValues(importedModule.reExportedAs, id, v);
+    for (const [id, v] of importItems.reExportedNs.entries())
+        addValues(importedModule.reExportedNs, id, v);
+};
+export const updateImportMap = (file, importMap, graph) => {
+    for (const [importedFilePath, importDetails] of importMap.entries()) {
+        const importedFileImports = file.imports.internal.get(importedFilePath);
+        if (!importedFileImports)
+            file.imports.internal.set(importedFilePath, importDetails);
+        else
+            updateImportDetails(importedFileImports, importDetails);
+        const importedFile = getOrCreateFileNode(graph, importedFilePath);
+        if (!importedFile.imported)
+            importedFile.imported = importDetails;
+        else
+            updateImportDetails(importedFile.imported, importDetails);
+        graph.set(importedFilePath, importedFile);
+    }
+};
+const createFileNode = () => ({
     imports: {
         internal: new Map(),
         external: new Set(),
@@ -37,14 +69,14 @@ export const addNsValue = (map, id, ns, value) => {
         map.set(id, new Map([[ns, new Set([value])]]));
     }
 };
-export const addValues = (map, id, values) => {
+const addValues = (map, id, values) => {
     if (map.has(id))
         for (const v of values)
             map.get(id)?.add(v);
     else
         map.set(id, values);
 };
-export const addNsValues = (map, id, value) => {
+const addNsValues = (map, id, value) => {
     if (map.has(id))
         for (const [ns, v] of value)
             addValues(map.get(id), ns, v);

package/dist/util/get-included-issue-types.d.ts

@@ -1,10 +1,10 @@
 import type { Report } from '../types/issues.js';
-type CLIArguments = {
-    include: string[];
-    exclude: string[];
-    dependencies: boolean;
-    exports: boolean;
-    files: boolean;
+export type CLIArguments = {
+    includedIssueTypes: string[];
+    excludedIssueTypes: string[];
+    isDependenciesShorthand: boolean;
+    isExportsShorthand: boolean;
+    isFilesShorthand: boolean;
 };
 type Options = {
     isProduction?: boolean;

package/dist/util/get-included-issue-types.js

@@ -4,21 +4,21 @@ export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));
 export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
-    let incl = normalize(cliArgs.include);
-    const excl = normalize(cliArgs.exclude);
+    let incl = normalize(cliArgs.includedIssueTypes);
+    const excl = normalize(cliArgs.excludedIssueTypes);
     for (const type of [...incl, ...excl, ...include, ...exclude]) {
         if (!ISSUE_TYPES.includes(type))
             throw new ConfigurationError(`Invalid issue type: ${type}`);
     }
     const excludes = exclude.filter(exclude => !incl.includes(exclude));
     const includes = include.filter(include => !excl.includes(include));
-    if (cliArgs.dependencies) {
+    if (cliArgs.isDependenciesShorthand) {
         incl = [...incl, 'dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
     }
-    if (cliArgs.exports) {
+    if (cliArgs.isExportsShorthand) {
         incl = [...incl, 'exports', 'types', 'enumMembers', 'duplicates'];
     }
-    if (cliArgs.files) {
+    if (cliArgs.isFilesShorthand) {
         incl = [...incl, 'files'];
     }
     const _include = [...incl, ...includes];

package/dist/util/globby.js

@@ -7,7 +7,7 @@ import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { timerify } from './Performance.js';
 import { debugLogObject } from './debug.js';
 import { isFile } from './fs.js';
-import { dirname, join, relative, toPosix } from './path.js';
+import { dirname, join, relative, toPosix, toRelative } from './path.js';
 const walk = promisify(_walk);
 const _picomatch = timerify(picomatch);
 const cachedIgnores = new Map();
@@ -53,7 +53,7 @@ async function parseFindGitignores(options) {
         return false;
     };
     const addFile = (filePath) => {
-        gitignoreFiles.push(filePath);
+        gitignoreFiles.push(toRelative(filePath));
         const dir = dirname(toPosix(filePath));
         const base = relative(options.cwd, dir);
         const dirIgnores = base === '' ? ['.git', ...GLOBAL_IGNORE_PATTERNS] : [];

package/dist/util/handle-dependency.d.ts

@@ -1,4 +1,4 @@
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
-export declare const getHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;
+export declare const getReferencedDependencyHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief) => (specifier: string, containingFilePath: string, workspace: Workspace) => string | undefined;

package/dist/util/handle-dependency.js

@@ -3,7 +3,7 @@ import { isInNodeModules, isInternal } from './path.js';
 import { fromBinary, isBinary } from './protocols.js';
 import { _resolveSpecifier } from './require.js';
 import { resolveSync } from './resolve.js';
-export const getHandler = (collector, deputy, chief) => (specifier, containingFilePath, workspace) => {
+export const getReferencedDependencyHandler = (collector, deputy, chief) => (specifier, containingFilePath, workspace) => {
     if (isBinary(specifier)) {
         const binaryName = fromBinary(specifier);
         const isHandled = deputy.maybeAddReferencedBinary(workspace, binaryName);

package/dist/util/reporter.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-export declare const runPreprocessors: (data: ReporterOptions, processors?: any) => Promise<ReporterOptions>;
-export declare const runReporters: (options: ReporterOptions) => Promise<void>;
+export declare const runPreprocessors: (processors: string[], data: ReporterOptions) => Promise<ReporterOptions>;
+export declare const runReporters: (reporter: string[], options: ReporterOptions) => Promise<void>;

package/dist/util/reporter.js

@@ -1,16 +1,18 @@
 import internalReporters from '../reporters/index.js';
-import parsedArgValues from '../util/cli-arguments.js';
 import { _load } from './loader.js';
 import { isInternal, resolve } from './path.js';
-const { preprocessor = [], reporter = ['symbols'] } = parsedArgValues;
-const preprocessors = await Promise.all(preprocessor.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
-export const runPreprocessors = (data, processors = preprocessors) => processors.length === 0 ? Promise.resolve(data) : runPreprocessors(processors[0](data), processors.slice(1));
-const reporters = await Promise.all(reporter.map(async (reporter) => {
-    return reporter in internalReporters
-        ? internalReporters[reporter]
-        : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
-}));
-export const runReporters = async (options) => {
+export const runPreprocessors = async (processors, data) => {
+    const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
+    return preprocessors.length === 0
+        ? Promise.resolve(data)
+        : runPreprocessors(preprocessors.slice(1), preprocessors[0](data));
+};
+export const runReporters = async (reporter, options) => {
+    const reporters = await Promise.all(reporter.map(async (reporter) => {
+        return reporter in internalReporters
+            ? internalReporters[reporter]
+            : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
+    }));
     for (const reporter of reporters)
         await reporter(options);
 };

package/dist/util/to-source-path.d.ts

@@ -1,5 +1,5 @@
 import type { CompilerOptions } from 'typescript';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
-export type ToSourceFilePath = (filePath: string) => undefined | string;
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
-export declare const getToSourcePathHandler: (chief: ConfigurationChief) => ToSourceFilePath;
+export declare const getToSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
+export type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;

package/dist/util/watch.d.ts

@@ -0,0 +1,25 @@
+import type { WatchListener } from 'node:fs';
+import type { ConfigurationChief } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { ProjectPrincipal } from '../ProjectPrincipal.js';
+import type { DependencyGraph } from '../types/dependency-graph.js';
+import type { Report } from '../types/issues.js';
+type Watch = {
+    analyzedFiles: Set<string>;
+    analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    collectUnusedExports: () => Promise<void>;
+    cwd: string;
+    factory: PrincipalFactory;
+    graph: DependencyGraph;
+    isDebug: boolean;
+    isIgnored: (path: string) => boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    unreferencedFiles: Set<string>;
+};
+export declare const getWatchHandler: ({ analyzedFiles, analyzeSourceFile, chief, collector, collectUnusedExports, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer>>;
+export {};

package/dist/util/watch.js

@@ -0,0 +1,85 @@
+import watchReporter from '../reporters/watch.js';
+import { debugLog } from './debug.js';
+import { updateImportMap } from './dependency-graph.js';
+import { isFile } from './fs.js';
+import { join, toPosix } from './path.js';
+export const getWatchHandler = async ({ analyzedFiles, analyzeSourceFile, chief, collector, collectUnusedExports, cwd, factory, graph, isDebug, isIgnored, report, streamer, unreferencedFiles, }) => {
+    const reportIssues = async (startTime) => {
+        const { issues } = collector.getIssues();
+        watchReporter({ report, issues, streamer, startTime, size: analyzedFiles.size, isDebug });
+    };
+    const listener = async (eventType, filename) => {
+        debugLog('*', `(raw) ${eventType} ${filename}`);
+        if (typeof filename === 'string') {
+            const startTime = performance.now();
+            const filePath = join(cwd, toPosix(filename));
+            if (isIgnored(filePath)) {
+                debugLog('*', `ignoring ${eventType} ${filename}`);
+                return;
+            }
+            const workspace = chief.findWorkspaceByFilePath(filePath);
+            if (workspace) {
+                const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                if (principal) {
+                    const event = eventType === 'rename' ? (isFile(filePath) ? 'added' : 'deleted') : 'modified';
+                    principal.invalidateFile(filePath);
+                    unreferencedFiles.clear();
+                    const cachedUnusedFiles = collector.purge();
+                    switch (event) {
+                        case 'added':
+                            principal.addProjectPath(filePath);
+                            principal.deletedFiles.delete(filePath);
+                            cachedUnusedFiles.add(filePath);
+                            debugLog(workspace.name, `Watcher: + ${filename}`);
+                            break;
+                        case 'deleted':
+                            analyzedFiles.delete(filePath);
+                            principal.removeProjectPath(filePath);
+                            cachedUnusedFiles.delete(filePath);
+                            debugLog(workspace.name, `Watcher: - ${filename}`);
+                            break;
+                        case 'modified':
+                            debugLog(workspace.name, `Watcher: ± ${filename}`);
+                            break;
+                    }
+                    const filePaths = principal.getUsedResolvedFiles();
+                    if (event === 'added' || event === 'deleted') {
+                        graph.clear();
+                        for (const filePath of filePaths)
+                            analyzeSourceFile(filePath, principal);
+                    }
+                    else {
+                        for (const [filePath, file] of graph) {
+                            if (filePaths.includes(filePath)) {
+                                file.imported = undefined;
+                            }
+                            else {
+                                graph.delete(filePath);
+                                analyzedFiles.delete(filePath);
+                                cachedUnusedFiles.add(filePath);
+                            }
+                        }
+                        for (const filePath of filePaths)
+                            if (!graph.has(filePath))
+                                analyzeSourceFile(filePath, principal);
+                        if (!cachedUnusedFiles.has(filePath))
+                            analyzeSourceFile(filePath, principal);
+                        for (const filePath of filePaths) {
+                            const file = graph.get(filePath);
+                            if (file?.internalImportCache)
+                                updateImportMap(file, file.internalImportCache, graph);
+                        }
+                    }
+                    await collectUnusedExports();
+                    const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
+                    collector.addFilesIssues(unusedFiles);
+                    collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
+                    await reportIssues(startTime);
+                }
+            }
+        }
+    };
+    await collectUnusedExports();
+    await reportIssues();
+    return listener;
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.26.0";
+export declare const version = "5.27.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.26.0';
+export const version = '5.27.0';