knip 6.34.0 → 6.35.0

package/dist/types/config.d.ts

@@ -1,7 +1,7 @@
 import type { Program, VisitorObject } from 'oxc-parser';
 import type { Word } from 'unbash';
 import type { z } from 'zod/mini';
-import type { AsyncCompilers, CompilerSync, HasDependency, SyncCompilers } from '../compilers/types.ts';
+import type { Compiler, HasDependency, RawCompilers } from '../compilers/types.ts';
 import type { knipConfigurationSchema, workspaceConfigurationSchema } from '../schema/configuration.ts';
 import type { pluginSchema } from '../schema/plugins.ts';
 import type { ParsedCLIArgs } from '../util/cli-arguments.ts';
@@ -56,8 +56,7 @@ export interface Configuration {
     ignoreUnresolved: IgnorePatterns;
     ignoreWorkspaces: string[];
     isIncludeEntryExports: boolean;
-    syncCompilers: SyncCompilers;
-    asyncCompilers: AsyncCompilers;
+    compilers: RawCompilers;
     rootPluginConfigs: Partial<PluginsConfiguration>;
 }
 type NormalizedGlob = string[];
@@ -121,7 +120,7 @@ export type ResolveSourceMap = (options: ResolveSourceMapOptions) => Promise<Sou
 export type HandleInput = (input: Input) => string | undefined;
 type RegisterCompilerInput = {
     extension: string;
-    compiler: CompilerSync;
+    compiler: Compiler;
 };
 export type RegisterCompiler = (input: RegisterCompilerInput) => void;
 export type ResolveFromAST = (program: Program, options: PluginOptions & {
@@ -143,6 +142,7 @@ export type PluginVisitorContext = {
         base?: string;
         cwd?: string;
         filter?: RegExp;
+        analyzeExports?: boolean;
     }) => void;
     markExportRegistered: (name: string) => void;
 };

package/dist/types/module-graph.d.ts

@@ -58,6 +58,7 @@ export interface ExportMember extends Position {
 type ExportMap = Map<Identifier, Export>;
 export type Imports = Set<Import>;
 export type FileNode = {
+    skipExports: boolean;
     imports: {
         readonly internal: ImportMap;
         readonly external: Set<Import>;
@@ -79,6 +80,7 @@ export interface ImportGlob {
     base?: string;
     cwd?: string;
     filter?: RegExp;
+    analyzeExports?: boolean;
 }
 export type ModuleGraph = Map<FilePath, FileNode>;
 export {};

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type { Compiler, CompilerResult } from './compilers/types.ts';
 export type { RawConfigurationOrFn as KnipConfig, RawConfiguration as KnipConfiguration, WorkspaceProjectConfig, } from './types/config.ts';
 export type { Issue, IssueRecords, IssueType, Preprocessor, Reporter, ReporterOptions } from './types/issues.ts';
 export type { JSONReport, JSONReportEntry, JSONReportItem, JSONReportNamedItem } from './reporters/json.ts';

package/dist/typescript/SourceFileManager.d.ts

@@ -1,15 +1,19 @@
-import type { AsyncCompilers, SyncCompilers } from '../compilers/types.ts';
+import type { Compilers } from '../compilers/types.ts';
 interface SourceFileManagerOptions {
-    compilers: [SyncCompilers, AsyncCompilers];
+    compilers: Compilers;
+    isSession?: boolean;
 }
 export declare class SourceFileManager {
-    sourceTextCache: Map<string, string>;
-    syncCompilers: SyncCompilers;
-    asyncCompilers: AsyncCompilers;
-    constructor({ compilers }: SourceFileManagerOptions);
-    readFile(filePath: string): string;
+    sourceTextCache: Map<string, string | Promise<string>>;
+    compilers: Compilers;
+    private rawContentHashes;
+    private isSession;
+    constructor({ compilers, isSession }: SourceFileManagerOptions);
+    loadSourceText(filePath: string): string | Promise<string>;
     invalidate(filePath: string): void;
-    compileAndAddSourceFile(filePath: string): Promise<void>;
-    private readRawFile;
+    hasChanged(filePath: string): boolean;
+    readRawFile(filePath: string): string | undefined;
+    private cacheSourceText;
+    private validateCompilerResult;
 }
 export {};

package/dist/typescript/SourceFileManager.js

@@ -1,21 +1,24 @@
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { debugLog } from '../util/debug.js';
+import { CompilerError, ConfigurationError } from '../util/errors.js';
 import { extname, isInternal } from '../util/path.js';
 export class SourceFileManager {
     sourceTextCache = new Map();
-    syncCompilers;
-    asyncCompilers;
-    constructor({ compilers }) {
-        this.syncCompilers = compilers[0];
-        this.asyncCompilers = compilers[1];
+    compilers;
+    rawContentHashes = new Map();
+    isSession;
+    constructor({ compilers, isSession = false }) {
+        this.compilers = compilers;
+        this.isSession = isSession;
     }
-    readFile(filePath) {
+    loadSourceText(filePath) {
         const cachedSourceText = this.sourceTextCache.get(filePath);
         if (cachedSourceText !== undefined)
             return cachedSourceText;
         const ext = extname(filePath);
-        const compiler = this.syncCompilers.get(ext);
+        const compiler = this.compilers.get(ext);
         if (FOREIGN_FILE_EXTENSIONS.has(ext) && !compiler) {
             this.sourceTextCache.set(filePath, '');
             return '';
@@ -27,26 +30,47 @@ export class SourceFileManager {
             this.sourceTextCache.set(filePath, '');
             return '';
         }
-        const compiled = compiler ? compiler(contents, filePath) : contents;
-        if (compiler)
-            debugLog('*', `Compiled ${filePath}`);
-        this.sourceTextCache.set(filePath, compiled);
-        return compiled;
+        if (!compiler)
+            return this.cacheSourceText(filePath, contents, contents);
+        let result;
+        try {
+            result = compiler(contents, filePath);
+            if (result !== null && (typeof result === 'object' || typeof result === 'function')) {
+                const pending = Promise.resolve(result).then(result => {
+                    const isCurrent = this.sourceTextCache.get(filePath) === pending;
+                    if (isCurrent)
+                        this.sourceTextCache.delete(filePath);
+                    const sourceText = this.validateCompilerResult(result, filePath, ext);
+                    if (isCurrent)
+                        this.cacheSourceText(filePath, sourceText, contents);
+                    debugLog('*', `Compiled ${filePath}`);
+                    return sourceText;
+                }, cause => {
+                    if (this.sourceTextCache.get(filePath) === pending)
+                        this.sourceTextCache.delete(filePath);
+                    throw new CompilerError(`Compiler for ${ext} failed (${filePath})`, { cause });
+                });
+                this.sourceTextCache.set(filePath, pending);
+                return pending;
+            }
+        }
+        catch (cause) {
+            throw new CompilerError(`Compiler for ${ext} failed (${filePath})`, { cause });
+        }
+        const sourceText = this.validateCompilerResult(result, filePath, ext);
+        debugLog('*', `Compiled ${filePath}`);
+        return this.cacheSourceText(filePath, sourceText, contents);
     }
     invalidate(filePath) {
         this.sourceTextCache.delete(filePath);
+        this.rawContentHashes.delete(filePath);
     }
-    async compileAndAddSourceFile(filePath) {
+    hasChanged(filePath) {
+        const previousHash = this.rawContentHashes.get(filePath);
+        if (previousHash === undefined)
+            return true;
         const contents = this.readRawFile(filePath);
-        if (contents === undefined)
-            throw new Error(`Unable to read ${filePath}`);
-        const ext = extname(filePath);
-        const compiler = this.asyncCompilers.get(ext);
-        if (compiler) {
-            const compiled = await compiler(contents, filePath);
-            debugLog('*', `Compiled ${filePath}`);
-            this.sourceTextCache.set(filePath, compiled);
-        }
+        return contents === undefined || createHash('sha1').update(contents).digest('hex') !== previousHash;
     }
     readRawFile(filePath) {
         try {
@@ -56,4 +80,16 @@ export class SourceFileManager {
             return undefined;
         }
     }
+    cacheSourceText(filePath, sourceText, contents) {
+        this.sourceTextCache.set(filePath, sourceText);
+        if (this.isSession)
+            this.rawContentHashes.set(filePath, createHash('sha1').update(contents).digest('hex'));
+        return sourceText;
+    }
+    validateCompilerResult(result, filePath, ext) {
+        if (typeof result === 'string')
+            return result;
+        const category = result === null ? 'null' : typeof result;
+        throw new ConfigurationError(`Compiler for ${ext} returned ${category} for ${filePath}; expected a string or PromiseLike<string>`);
+    }
 }

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

@@ -283,7 +283,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
         pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
-        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, cwd: opts?.cwd, filter: opts?.filter });
+        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, ...opts });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
     const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {
@@ -329,6 +329,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         }
     }
     return {
+        skipExports,
         imports: { internal, external, externalRefs: new Set(), programFiles, entryFiles, imports, unresolved },
         exports,
         duplicates: [...aliasedExports.values()],

package/dist/typescript/visitors/exports.js

@@ -123,10 +123,14 @@ export function handleExportNamed(node, s) {
                                         s.accessedAliases.add(name);
                                     }
                                 }
-                                else if (prop.type === 'Property' &&
-                                    prop.value?.type === 'ObjectExpression' &&
-                                    prop.key?.type === 'Identifier') {
-                                    findSpreads(prop.value, [...path, prop.key.name]);
+                                else if (prop.type === 'Property' && prop.value?.type === 'ObjectExpression') {
+                                    const key = prop.key?.type === 'Identifier'
+                                        ? prop.key.name
+                                        : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
+                                            ? prop.key.value
+                                            : undefined;
+                                    if (key)
+                                        findSpreads(prop.value, [...path, key]);
                                 }
                             }
                         };

package/dist/util/catalog.d.ts

@@ -4,8 +4,13 @@ export declare const DEFAULT_CATALOG = "default";
 export type CatalogReference = {
     catalogName: string;
     packageName: string;
+    selector?: string;
+};
+export type OverrideCatalogReference = CatalogReference & {
+    selector: string;
 };
 export declare const getCatalogReference: (specifier: string) => CatalogReference | undefined;
 export declare const getCatalogContainer: (cwd: string, manifest: PackageJson, manifestPath: string, pnpmWorkspacePath?: string, pnpmWorkspace?: any) => Promise<CatalogContainer>;
 export declare const parseCatalog: (container: CatalogContainer) => Set<string>;
+export declare const getOverrideCatalogReferences: (overrides: Record<string, string> | undefined) => OverrideCatalogReference[];
 export declare const extractCatalogReferences: (manifest: PackageJson) => CatalogReference[];

package/dist/util/catalog.js

@@ -27,7 +27,7 @@ export const getCatalogContainer = async (cwd, manifest, manifestPath, pnpmWorks
         yarnWorkspace?.catalogs ??
         manifest.catalogs ??
         ((!Array.isArray(manifest.workspaces) && manifest.workspaces?.catalogs) || {});
-    return { filePath, catalog, catalogs };
+    return { filePath, catalog, catalogs, overrides: pnpmWorkspace?.overrides };
 };
 const extractEntries = (catalog) => {
     if (catalog && typeof catalog === 'object')
@@ -56,23 +56,43 @@ export const parseCatalog = (container) => {
             entries.add(id);
     return entries;
 };
+const OVERRIDE_DELIMITER = /[^ |@]>/;
+const toCatalogReference = (packageName, version) => {
+    if (typeof version !== 'string' || !version.startsWith('catalog:'))
+        return;
+    return { catalogName: version.slice('catalog:'.length) || DEFAULT_CATALOG, packageName };
+};
+const collectCatalogReferences = (dependencies, catalogReferences) => {
+    if (!dependencies)
+        return;
+    for (const [packageName, version] of Object.entries(dependencies)) {
+        const reference = toCatalogReference(packageName, version);
+        if (reference)
+            catalogReferences.push(reference);
+    }
+};
+export const getOverrideCatalogReferences = (overrides) => {
+    const catalogReferences = [];
+    if (!overrides)
+        return catalogReferences;
+    for (const [selector, version] of Object.entries(overrides)) {
+        const delimiterIndex = selector.search(OVERRIDE_DELIMITER);
+        const target = delimiterIndex === -1 ? selector : selector.slice(delimiterIndex + 2);
+        const packageName = getPackageNameFromModuleSpecifier(target);
+        if (!packageName)
+            continue;
+        const reference = toCatalogReference(packageName, version);
+        if (reference)
+            catalogReferences.push({ ...reference, selector });
+    }
+    return catalogReferences;
+};
 export const extractCatalogReferences = (manifest) => {
     const catalogReferences = [];
-    const checkDependencies = (dependencies) => {
-        if (!dependencies)
-            return;
-        for (const [name, version] of Object.entries(dependencies)) {
-            if (typeof version === 'string' && version.startsWith('catalog:')) {
-                const catalogName = version.slice('catalog:'.length) || DEFAULT_CATALOG;
-                catalogReferences.push({ catalogName, packageName: name });
-            }
-        }
-    };
-    checkDependencies(manifest.dependencies);
-    checkDependencies(manifest.devDependencies);
-    checkDependencies(manifest.peerDependencies);
-    checkDependencies(manifest.optionalDependencies);
-    checkDependencies(manifest.resolutions);
-    checkDependencies(manifest.pnpm?.overrides);
+    collectCatalogReferences(manifest.dependencies, catalogReferences);
+    collectCatalogReferences(manifest.devDependencies, catalogReferences);
+    collectCatalogReferences(manifest.peerDependencies, catalogReferences);
+    collectCatalogReferences(manifest.optionalDependencies, catalogReferences);
+    collectCatalogReferences(manifest.resolutions, catalogReferences);
     return catalogReferences;
 };

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

@@ -366,6 +366,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mise?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mocha?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -975,12 +980,13 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         } | undefined;
         ignoreWorkspaces?: string[] | undefined;
         includeEntryExports?: boolean | undefined;
-        compilers?: Record<string, true | import("../compilers/types.ts").CompilerAsync | import("../compilers/types.ts").CompilerSync> | undefined;
-        syncCompilers?: Record<string, true | import("../compilers/types.ts").CompilerSync> | undefined;
-        asyncCompilers?: Record<string, import("../compilers/types.ts").CompilerAsync> | undefined;
+        compilers?: Record<string, true | import("../types.ts").Compiler> | undefined;
+        asyncCompilers?: Record<string, import("../types.ts").Compiler> | undefined;
         tags?: string[] | undefined;
         treatConfigHintsAsErrors?: boolean | undefined;
         treatTagHintsAsErrors?: boolean | undefined;
+        preprocessor?: string | string[] | undefined;
+        preprocessorOptions?: Record<string, unknown> | undefined;
         include?: ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
         exclude?: ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
         workspaces?: Record<string, {
@@ -1304,6 +1310,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            mise?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             mocha?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1908,6 +1919,9 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             includeEntryExports?: boolean | undefined;
         }> | undefined;
     };
+    preprocessor: string[];
+    preprocessorInputs: string[];
+    preprocessorOptions: string;
     rules: {
         binaries: import("../types/issues.ts").IssueSeverity;
         catalog: import("../types/issues.ts").IssueSeverity;

package/dist/util/create-options.js

@@ -1,6 +1,6 @@
-import { partitionCompilers } from '../compilers/index.js';
 import { ISSUE_TYPES, KNIP_CONFIG_LOCATIONS } from '../constants.js';
 import { knipConfigurationSchema } from '../schema/configuration.js';
+import { arrayify } from './array.js';
 import { getCatalogContainer } from './catalog.js';
 import { parseNumericOption } from './cli-arguments.js';
 import { ConfigurationError } from './errors.js';
@@ -11,7 +11,7 @@ import { loadResolvedConfigFile } from './load-config.js';
 import { _load } from './loader.js';
 import { logWarning } from './log.js';
 import { getKeysByValue } from './object.js';
-import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
+import { isAbsolute, isInternal, join, normalize, toAbsolute, toPosix } from './path.js';
 import { splitTags } from './tag.js';
 export const createOptions = async (options) => {
     const { args = {} } = options;
@@ -56,7 +56,7 @@ export const createOptions = async (options) => {
             }
         }
     }
-    const parsedConfig = knipConfigurationSchema.parse(partitionCompilers(loadedConfig));
+    const parsedConfig = knipConfigurationSchema.parse(loadedConfig);
     if (!configFilePath && manifest.knip)
         configFilePath = manifestPath;
     const pnpmWorkspacePath = findFile(cwd, 'pnpm-workspace.yaml');
@@ -94,6 +94,14 @@ export const createOptions = async (options) => {
     const isFixFiles = args['allow-remove-files'] && (fixTypes.length === 0 || fixTypes.includes('files'));
     const tags = splitTags(args.tags ?? options.tags ?? parsedConfig.tags ?? []);
     const workspace = options.workspace ?? args.workspace;
+    const toPreprocessor = (specifier) => (isInternal(specifier) ? toAbsolute(specifier, cwd) : specifier);
+    const configuredPreprocessor = arrayify(parsedConfig.preprocessor).map(toPreprocessor);
+    const preprocessor = args.preprocessor ? args.preprocessor.map(toPreprocessor) : configuredPreprocessor;
+    const preprocessorInputs = args.preprocessor
+        ? [...new Set([...configuredPreprocessor, ...preprocessor])]
+        : preprocessor;
+    const preprocessorOptions = args['preprocessor-options'] ??
+        (parsedConfig.preprocessorOptions ? JSON.stringify(parsedConfig.preprocessorOptions) : '');
     return {
         cacheLocation: args['cache-location'] ?? join(cwd, 'node_modules', '.cache', 'knip'),
         catalog: await getCatalogContainer(cwd, manifest, manifestPath, pnpmWorkspacePath, pnpmWorkspace),
@@ -154,6 +162,9 @@ export const createOptions = async (options) => {
         maxIssues: parseNumericOption(args['max-issues'], 'max-issues') ?? 0,
         maxShowIssues: parseNumericOption(args['max-show-issues'], 'max-show-issues'),
         parsedConfig,
+        preprocessor,
+        preprocessorInputs,
+        preprocessorOptions,
         rules,
         tags,
         traceDependency: args['trace-dependency'],

package/dist/util/errors.d.ts

@@ -4,9 +4,11 @@ interface ErrorWithCause extends Error {
 }
 export declare class ConfigurationError extends Error {
 }
+export declare class CompilerError extends Error {
+}
 export declare class LoaderError extends Error {
 }
-export declare const isKnownError: (error: Error) => error is core.$ZodError<any> | ConfigurationError | LoaderError;
+export declare const isKnownError: (error: Error) => error is core.$ZodError<any> | CompilerError | ConfigurationError | LoaderError;
 export declare const hasErrorCause: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
 export declare const isModuleNotFoundError: (error: Error) => boolean;

package/dist/util/errors.js

@@ -3,9 +3,14 @@ import { substringBefore } from './string.js';
 const isZodErrorLike = (error) => error instanceof core.$ZodError;
 export class ConfigurationError extends Error {
 }
+export class CompilerError extends Error {
+}
 export class LoaderError extends Error {
 }
-export const isKnownError = (error) => error instanceof ConfigurationError || error instanceof LoaderError || isZodErrorLike(error);
+export const isKnownError = (error) => error instanceof ConfigurationError ||
+    error instanceof CompilerError ||
+    error instanceof LoaderError ||
+    isZodErrorLike(error);
 export const hasErrorCause = (error) => !isZodErrorLike(error) && error.cause instanceof Error;
 export const isConfigurationError = (error) => error instanceof ConfigurationError;
 export const isModuleNotFoundError = (error) => 'code' in error && error.code === 'MODULE_NOT_FOUND';

package/dist/util/file-entry-cache.js

@@ -4,7 +4,7 @@ import { deserialize, serialize } from 'node:v8';
 import { debugLog } from './debug.js';
 import { isDirectory, isFile } from './fs.js';
 import { timerify } from './Performance.js';
-import { dirname, isAbsolute, resolve } from './path.js';
+import { isAbsolute, resolve } from './path.js';
 const createCache = (filePath) => {
     try {
         return deserialize(fs.readFileSync(filePath));
@@ -70,7 +70,7 @@ export class FileEntryCache {
     }
     reconcile() {
         try {
-            const dir = dirname(this.filePath);
+            const dir = path.dirname(this.filePath);
             if (!isDirectory(dir))
                 fs.mkdirSync(dir, { recursive: true });
             fs.writeFileSync(this.filePath, serialize(this.cache));

package/dist/util/module-graph.js

@@ -35,6 +35,7 @@ export const updateImportMap = (file, importMap, graph) => {
     }
 };
 export const createFileNode = () => ({
+    skipExports: false,
     imports: {
         internal: new Map(),
         external: new Set(),

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

@@ -231,6 +231,7 @@ export declare const getPublishedTypeManifest: (manifest: PackageJson) => {
     mdx: unknown;
     mdxlint: unknown;
     metro: unknown;
+    mise: unknown;
     mocha: unknown;
     moonrepo: unknown;
     msw: unknown;

package/dist/util/preprocessor.d.ts

@@ -0,0 +1,6 @@
+import type { Results } from '../run.ts';
+import type { ReporterOptions } from '../types/issues.ts';
+import type { ParsedCLIArgs } from './cli-arguments.ts';
+import type { MainOptions } from './create-options.ts';
+export declare const toReporterOptions: (options: MainOptions, results: Results, args?: ParsedCLIArgs) => ReporterOptions;
+export declare const createPreprocessor: (processors: string[]) => Promise<(data: ReporterOptions) => Promise<ReporterOptions>>;

package/dist/util/preprocessor.js

@@ -0,0 +1,24 @@
+import { _load } from './loader.js';
+export const toReporterOptions = (options, results, args) => ({
+    ...results,
+    report: options.includedIssueTypes,
+    cwd: options.cwd,
+    configFilePath: options.configFilePath,
+    isDisableConfigHints: options.isDisableConfigHints,
+    isDisableTagHints: options.isDisableTagHints,
+    isProduction: options.isProduction,
+    isShowProgress: options.isShowProgress,
+    isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
+    isTreatTagHintsAsErrors: options.isTreatTagHintsAsErrors,
+    maxShowIssues: options.maxShowIssues,
+    options: args?.['reporter-options'] ?? '',
+    preprocessorOptions: options.preprocessorOptions,
+});
+export const createPreprocessor = async (processors) => {
+    const preprocessors = await Promise.all(processors.map(_load));
+    return async (data) => {
+        for (const preprocessor of preprocessors)
+            data = await preprocessor(data);
+        return data;
+    };
+};

package/dist/util/reporter.d.ts

@@ -1,3 +1,2 @@
 import type { ReporterOptions } from '../types/issues.ts';
-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,13 +1,6 @@
 import internalReporters from '../reporters/index.js';
 import { _load } from './loader.js';
 import { isAbsolute, isInternal, resolve } from './path.js';
-export const runPreprocessors = async (processors, data) => {
-    const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) && !isAbsolute(proc) ? resolve(proc) : proc)));
-    let result = data;
-    for (const preprocessor of preprocessors)
-        result = await preprocessor(result);
-    return result;
-};
 export const runReporters = async (reporter, options) => {
     const reporters = await Promise.all(reporter.map(async (reporter) => {
         return reporter in internalReporters

package/dist/util/watch.d.ts

@@ -17,7 +17,7 @@ export type WatchChange = {
 export type SessionHandler = Awaited<ReturnType<typeof getSessionHandler>>;
 type WatchOptions = {
     analyzedFiles: Set<string>;
-    analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+    analyzeSourceFile: (filePath: string) => Promise<void>;
     chief: ConfigurationChief;
     collector: IssueCollector;
     analyze: () => Promise<void>;