knip 6.34.0 → 6.35.1

package/dist/plugins/mise/index.js

@@ -0,0 +1,82 @@
+import { isFile } from '../../util/fs.js';
+import { isEntry } from '../../util/input.js';
+import { basename, dirname, join, toAbsolute } from '../../util/path.js';
+const title = 'mise';
+const enablers = 'This plugin is enabled when `mise.toml` or `.mise.toml` is found.';
+const config = [
+    '{mise,.mise}{,.*}.toml',
+    '{mise,.mise}/config{,.*}.toml',
+    '.config/mise{,.*}.toml',
+    '.config/mise/config{,.*}.toml',
+    '.config/mise/mise{,.local}.toml',
+    '{mise,.mise}/conf.d/[!.]*.toml',
+    '.config/mise/conf.d/[!.]*.toml',
+];
+const isEnabled = ({ cwd }) => isFile(cwd, 'mise.toml') || isFile(cwd, '.mise.toml');
+const getConfigRoot = (configFileDir, configFileName) => {
+    const isFragment = basename(configFileDir) === 'conf.d';
+    const groupedDir = isFragment ? dirname(configFileDir) : configFileDir;
+    const name = basename(groupedDir);
+    const root = (isFragment || configFileName.startsWith('config.')) && (name === 'mise' || name === '.mise')
+        ? dirname(groupedDir)
+        : configFileDir;
+    return basename(root) === '.config' ? dirname(root) : root;
+};
+const hasTemplate = (value) => value.includes('{{') || value.includes('{%');
+const resolvePath = (value, root) => {
+    const expanded = value.replace(/\{\{\s*config_root\s*\}\}/g, () => root);
+    if (hasTemplate(expanded) || expanded.startsWith('~') || expanded.includes('$'))
+        return;
+    return join(toAbsolute(expanded, root), '.');
+};
+const resolveConfig = async (localConfig, options) => {
+    const { getInputsFromMiseScript } = await import('./scripts.js');
+    const { configFileDir, configFileName, getManifest, isProduction } = options;
+    const configRoot = getConfigRoot(configFileDir, configFileName);
+    const inputs = [];
+    for (const task of Object.values(localConfig.tasks ?? {})) {
+        const taskConfig = typeof task === 'string' || Array.isArray(task) ? { run: task } : task;
+        const dir = resolvePath(taskConfig.dir ?? localConfig.task_config?.dir ?? '.', configRoot);
+        if (!dir)
+            continue;
+        let hasLocalBinPath = false;
+        for (const env of [localConfig.env ?? [], taskConfig.env ?? []].flat()) {
+            if (Object.hasOwn(env, 'PATH'))
+                hasLocalBinPath = false;
+            const paths = env._?.path;
+            for (const path of typeof paths === 'string' ? [paths] : Array.isArray(paths) ? paths : []) {
+                if (typeof path === 'string' && resolvePath(path, configRoot) === join(dir, 'node_modules/.bin')) {
+                    hasLocalBinPath = true;
+                }
+            }
+        }
+        const manifest = getManifest(dir) ?? options.manifest;
+        const scriptOptions = {
+            ...options,
+            cwd: dir,
+            manifest,
+            containingFilePath: options.configFilePath,
+        };
+        for (const script of [taskConfig.run ?? [], taskConfig.run_windows ?? []].flat()) {
+            if (typeof script !== 'string' || hasTemplate(script))
+                continue;
+            for (const input of getInputsFromMiseScript(script, scriptOptions, hasLocalBinPath)) {
+                if (isProduction)
+                    input.optional = true;
+                input.dir ??= dir;
+                if (isEntry(input))
+                    input.specifier = toAbsolute(input.specifier, input.dir);
+                inputs.push(input);
+            }
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/mise/scripts.d.ts

@@ -0,0 +1,7 @@
+import type { GetInputsFromScriptsOptions, GetInputsFromScriptsPartial } from '../../types/config.ts';
+import { type Input } from '../../util/input.ts';
+type Options = GetInputsFromScriptsOptions & {
+    getInputsFromScripts: GetInputsFromScriptsPartial;
+};
+export declare const getInputsFromMiseScript: (script: string, options: Options, hasLocalBinPath: boolean) => Input[];
+export {};

package/dist/plugins/mise/scripts.js

@@ -0,0 +1,108 @@
+import { parse } from 'unbash';
+import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
+import { spawningBinaries } from '../../binaries/fallback.js';
+import { isWrapper } from '../../binaries/plugins.js';
+import KnownResolvers from '../../binaries/resolvers/index.js';
+import { toScript } from '../../binaries/util.js';
+import { SCRIPT_INTERPOLATION } from '../../constants.js';
+import { isBinary } from '../../util/input.js';
+import { extractBinary } from '../../util/modules.js';
+import { walkCommands } from '../../util/scripts.js';
+export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
+    const inputs = [];
+    const definedFunctions = new Set();
+    const readParts = (parts) => {
+        let text = '';
+        let value = '';
+        let hasExpansion = false;
+        for (const part of parts) {
+            if (part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') {
+                if (part.script)
+                    readScript(part.script);
+                text += SCRIPT_INTERPOLATION;
+                value += SCRIPT_INTERPOLATION;
+                hasExpansion = true;
+            }
+            else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
+                const inner = readParts(part.parts);
+                text += `${part.type === 'LocaleString' ? '$"' : '"'}${inner.text}"`;
+                value += inner.value;
+                if (inner.hasExpansion)
+                    hasExpansion = true;
+            }
+            else {
+                text += part.text;
+                value += 'value' in part ? part.value : part.text;
+            }
+        }
+        return { text, value, hasExpansion };
+    };
+    const readWord = (word) => {
+        if (!word.parts)
+            return word;
+        const { text, value, hasExpansion } = readParts(word.parts);
+        return hasExpansion ? { ...word, text, value } : word;
+    };
+    const readScript = (parsed) => {
+        for (const statement of parsed.commands) {
+            if (statement.command.type === 'Function')
+                definedFunctions.add(statement.command.name.value);
+        }
+        for (const statement of parsed.commands) {
+            for (const command of walkCommands(statement.command)) {
+                const name = command.name?.value;
+                const word = command.name && readWord(command.name);
+                const prefix = command.prefix.map(assignment => {
+                    const value = assignment.value && readWord(assignment.value);
+                    return value && value !== assignment.value
+                        ? { ...assignment, value, text: `${assignment.name}=${value.text}` }
+                        : assignment;
+                });
+                const words = command.suffix.map(readWord);
+                if (!name || !word || definedFunctions.has(name))
+                    continue;
+                const binary = extractBinary(name);
+                const isPackageManager = binary in KnownResolvers && binary !== 'find';
+                const isExplicit = isPackageManager || name.startsWith('./') || /^(?:\.\.?\/)*node_modules\/\.bin\//.test(name);
+                const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
+                const isWrapperCommand = !isPackageManager && isWrapper(binary);
+                if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                    continue;
+                let commandInputs;
+                if (isWrapperCommand || binary === 'find') {
+                    const fromScript = (script) => {
+                        inputs.push(...getInputsFromMiseScript(script, options, isLocal));
+                        return [];
+                    };
+                    const fromArgs = args => fromScript(toScript(args));
+                    commandInputs = getDependenciesFromCommand({ ...command, name: word, prefix, suffix: words }, { ...options, fromArgs });
+                }
+                else {
+                    commandInputs = options.getInputsFromScripts([...prefix.map(assignment => assignment.text), word.text, ...words.map(word => word.text)].join(' '), { cwd: options.cwd, manifest: options.manifest });
+                }
+                if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                    continue;
+                if (isWrapperCommand && spawningBinaries.includes(binary)) {
+                    commandInputs.push(...getInputsFromNodeOptions(prefix));
+                }
+                const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
+                if (!isExplicit && isLocal && binaryInput)
+                    binaryInput.optional = true;
+                for (const input of commandInputs) {
+                    if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
+                        continue;
+                    if (!isExplicit && !isLocal && input === binaryInput)
+                        continue;
+                    inputs.push(input);
+                }
+            }
+        }
+    };
+    try {
+        readScript(parse(script));
+    }
+    catch {
+        return [];
+    }
+    return inputs;
+};

package/dist/plugins/mise/types.d.ts

@@ -0,0 +1,26 @@
+type MiseEnvironment = {
+    PATH?: unknown;
+    _?: {
+        path?: string | string[];
+    };
+};
+type TaskReference = {
+    task: string;
+} | {
+    tasks: string[];
+};
+type Run = string | (string | TaskReference)[];
+type MiseTask = {
+    run?: Run;
+    run_windows?: Run;
+    dir?: string;
+    env?: MiseEnvironment;
+};
+export type MiseConfig = {
+    tasks?: Record<string, string | string[] | MiseTask>;
+    env?: MiseEnvironment | MiseEnvironment[];
+    task_config?: {
+        dir?: string;
+    };
+};
+export {};

package/dist/plugins/mise/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/rstest/index.js

@@ -7,9 +7,10 @@ const config = ['rstest.config.{js,cjs,mjs,ts,cts,mts}'];
 const mocks = ['**/__mocks__/**/*.?(c|m)[jt]s?(x)'];
 const entry = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
 function testEnvironment(config) {
-    if (!config.testEnvironment || config.testEnvironment === 'node')
+    const environment = typeof config.testEnvironment === 'string' ? config.testEnvironment : config.testEnvironment?.name;
+    if (!environment || environment === 'node')
         return [];
-    return [config.testEnvironment];
+    return [environment];
 }
 const resolveConfig = async (config) => {
     const entries = (config.include ?? entry)

package/dist/plugins/rstest/types.d.ts

@@ -1,6 +1,8 @@
 export type RstestConfig = {
     include?: string[];
     exclude?: string[];
-    testEnvironment?: 'node' | 'jsdom' | 'happy-dom';
+    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | {
+        name: 'node' | 'jsdom' | 'happy-dom';
+    };
     setupFiles?: string[];
 };

package/dist/plugins/vite/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
 export declare const getBabelInputs: (program: Program) => Input[];
-export declare const getHtmlScriptEntries: (htmlPath: string) => Promise<Input[]>;
-export declare const getIndexHtmlEntries: (rootDir: string) => Promise<Input[]>;
+export declare const getHtmlScriptEntries: (htmlPath: string, publicDir?: string) => Promise<Input[]>;
+export declare const getIndexHtmlEntries: (rootDir: string, publicDir?: string) => Promise<Input[]>;
 export declare const getVitePluginDirs: (program: Program, specifiers: string[], key: string) => string[] | undefined;

package/dist/plugins/vite/helpers.js

@@ -3,7 +3,7 @@ import { findImportedCalls, findProperty, getStringValues } from '../../typescri
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isFile, loadFile } from '../../util/fs.js';
 import { toProductionEntry } from '../../util/input.js';
-import { dirname, join } from '../../util/path.js';
+import { dirname, join, toAbsolute } from '../../util/path.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 const babelPluginSources = ['@rolldown/plugin-babel', '@vitejs/plugin-react', 'vite-plugin-babel'];
 const isBabelWrappingPlugin = (path) => babelPluginSources.some(source => path === source || path.startsWith(`${source}/`));
@@ -26,19 +26,26 @@ const srcAttrPattern = /\bsrc\s*=\s*["']([^"']+)["']/i;
 const importSpecPattern = /\bimport\b(?:\s*\(\s*|(?:[\w$*,{}\s]*\bfrom\b)?\s*)(['"])([^'"]+)\1/g;
 const isFilePath = (specifier) => specifier.startsWith('/') || specifier.startsWith('./') || specifier.startsWith('../');
 const normalizeModuleScriptSrc = (value) => value.trim().replace(/^\//, '');
-const getModuleScriptSources = (html) => {
+const getScriptSources = (html, publicDir) => {
     const sources = [];
     for (const [, attrs, body] of html.matchAll(scriptExtractor)) {
-        if (!moduleTypePattern.test(attrs))
-            continue;
         const srcMatch = attrs.match(srcAttrPattern);
         if (srcMatch) {
-            const src = normalizeModuleScriptSrc(srcMatch[1]);
-            if (src)
-                sources.push(src);
+            const src = srcMatch[1].trim();
+            if (!src || /^(?:[\w+.-]+:|\/\/)/.test(src))
+                continue;
+            if (publicDir && src.startsWith('/')) {
+                const publicPath = join(publicDir, src.split(/[?#]/, 1)[0]);
+                if (publicPath.startsWith(join(publicDir, '/')) && isFile(publicPath)) {
+                    sources.push(publicPath);
+                    continue;
+                }
+            }
+            if (moduleTypePattern.test(attrs))
+                sources.push(normalizeModuleScriptSrc(src));
             continue;
         }
-        if (body) {
+        if (moduleTypePattern.test(attrs) && body) {
             const code = body.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
             for (const importMatch of code.matchAll(importSpecPattern)) {
                 const specifier = importMatch[2];
@@ -49,14 +56,14 @@ const getModuleScriptSources = (html) => {
     }
     return sources;
 };
-export const getHtmlScriptEntries = async (htmlPath) => {
+export const getHtmlScriptEntries = async (htmlPath, publicDir) => {
     if (!isFile(htmlPath))
         return [];
     const html = await loadFile(htmlPath);
     const dir = dirname(htmlPath);
-    return getModuleScriptSources(html).map(src => toProductionEntry(join(dir, src)));
+    return getScriptSources(html, publicDir).map(src => toProductionEntry(toAbsolute(src, dir)));
 };
-export const getIndexHtmlEntries = (rootDir) => getHtmlScriptEntries(join(rootDir, 'index.html'));
+export const getIndexHtmlEntries = (rootDir, publicDir) => getHtmlScriptEntries(join(rootDir, 'index.html'), publicDir);
 export const getVitePluginDirs = (program, specifiers, key) => {
     let dirs;
     for (const call of findImportedCalls(program, specifiers)) {

package/dist/plugins/vite/visitors/importMetaGlob.js

@@ -1,4 +1,6 @@
+import { findProperty } from '../../../typescript/ast-helpers.js';
 import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+const RAW_QUERY_RE = /(\?|&)raw(?:&|$)/;
 export function createImportMetaGlobVisitor(ctx) {
     return {
         CallExpression(node) {
@@ -22,6 +24,16 @@ export function createImportMetaGlobVisitor(ctx) {
             }
             if (!patterns?.length)
                 return;
+            const options = node.arguments[1];
+            if (options?.type === 'ObjectExpression') {
+                const queryNode = findProperty(options, 'query');
+                const query = getStringValue(queryNode);
+                const isRaw = getStringValue(findProperty(options, 'as')) === 'raw' ||
+                    (query !== undefined && RAW_QUERY_RE.test(query.startsWith('?') ? query : `?${query}`)) ||
+                    getStringValue(findProperty(queryNode, 'raw')) === '';
+                if (isRaw)
+                    return ctx.addImportGlob(patterns, { analyzeExports: true });
+            }
             ctx.addImportGlob(patterns);
         },
     };

package/dist/plugins/vitest/index.js

@@ -2,7 +2,7 @@ import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { _glob } from '../../util/glob.js';
 import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal, join, toAbsolute } from '../../util/path.js';
+import { isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getIndexHtmlEntries } from '../vite/helpers.js';
 import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
@@ -137,7 +137,10 @@ export const resolveConfig = async (localConfig, options) => {
         const viteRoot = toAbsolute(cfg.root ?? '.', options.cwd);
         if (!seenRoots.has(viteRoot)) {
             seenRoots.add(viteRoot);
-            for (const entry of await getIndexHtmlEntries(viteRoot))
+            const publicDir = cfg.publicDir === false || cfg.publicDir === ''
+                ? undefined
+                : toAbsolute(toPosix(cfg.publicDir ?? 'public'), viteRoot);
+            for (const entry of await getIndexHtmlEntries(viteRoot, publicDir))
                 inputs.add(entry);
         }
         const vitestRoot = toAbsolute(cfg.test?.root ?? '.', options.cwd);

package/dist/plugins/vitest/types.d.ts

@@ -39,6 +39,7 @@ interface VitestConfig {
 export interface ViteConfig extends VitestConfig {
     extends?: string | true;
     root?: string;
+    publicDir?: string | false;
     plugins?: unknown[];
     build?: {
         lib?: {

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

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

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

@@ -128,8 +128,17 @@ export const finalizeConfigurationHints = (results, options) => {
         return row;
     }));
 };
-export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, enabledPlugins, isTreatConfigHintsAsErrors, includedWorkspaceDirs, selectedWorkspaces, configFilePath, }) => {
-    const rows = finalizeConfigurationHints({ issues, counters, configurationHints, tagHints, includedWorkspaceDirs, selectedWorkspaces, enabledPlugins }, { cwd, configFilePath });
+export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, hasConfigLoadErrors, enabledPlugins, isTreatConfigHintsAsErrors, includedWorkspaceDirs, selectedWorkspaces, configFilePath, }) => {
+    const rows = finalizeConfigurationHints({
+        issues,
+        counters,
+        configurationHints,
+        hasConfigLoadErrors,
+        tagHints,
+        includedWorkspaceDirs,
+        selectedWorkspaces,
+        enabledPlugins,
+    }, { cwd, configFilePath });
     if (rows.length > 0) {
         const getTitle = isTreatConfigHintsAsErrors ? getColoredTitle : getDimmedTitle;
         console.warn(getTitle('Configuration hints', configurationHints.length));

package/dist/run.d.ts

@@ -7,6 +7,7 @@ export declare const run: (options: MainOptions) => Promise<{
         counters: import("./types/issues.ts").Counters;
         tagHints: Set<import("./types/issues.ts").TagHint>;
         configurationHints: import("./types/issues.ts").ConfigurationHint[];
+        hasConfigLoadErrors: boolean;
         selectedWorkspaces: string[] | undefined;
         includedWorkspaceDirs: string[];
         enabledPlugins: {
@@ -26,6 +27,7 @@ export declare const run: (options: MainOptions) => Promise<{
             counters: import("./types/issues.ts").Counters;
             tagHints: Set<import("./types/issues.ts").TagHint>;
             configurationHints: import("./types/issues.ts").ConfigurationHint[];
+            hasConfigLoadErrors: boolean;
         };
     } | undefined;
     streamer: ConsoleStreamer;

package/dist/run.js

@@ -114,7 +114,7 @@ export const run = async (options) => {
         if (options.isWatch)
             watch('.', { recursive: true }, session.listener);
     }
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    const { issues, counters, tagHints, configurationHints, hasConfigLoadErrors } = collector.getIssues();
     if (!options.isWatch)
         streamer.clear();
     if (options.isCache) {
@@ -127,6 +127,7 @@ export const run = async (options) => {
             counters,
             tagHints,
             configurationHints,
+            hasConfigLoadErrors,
             selectedWorkspaces: chief.selectedWorkspaces ? Array.from(chief.selectedWorkspaces) : undefined,
             includedWorkspaceDirs: Array.from(chief.workspacesByDir.keys()),
             enabledPlugins: Object.fromEntries(enabledPluginsStore),

package/dist/schema/configuration.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod/mini';
-import type { CompilerAsync, CompilerSync } from '../compilers/types.ts';
+import type { Compiler } from '../compilers/types.ts';
 export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
     angular: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -321,6 +321,11 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1247,6 +1252,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1862,12 +1872,13 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     }, z.core.$strict>>;
     ignoreWorkspaces: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     includeEntryExports: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    compilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<CompilerSync, CompilerSync>]>, z.ZodMiniCustom<CompilerAsync, CompilerAsync>]>>>;
-    syncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<CompilerSync, CompilerSync>]>>>;
-    asyncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniCustom<CompilerAsync, CompilerAsync>>>;
+    compilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<Compiler, Compiler>]>>>;
+    asyncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniCustom<Compiler, Compiler>>>;
     tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     treatConfigHintsAsErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     treatTagHintsAsErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    preprocessor: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    preprocessorOptions: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
     include: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"namespaceMembers">, z.ZodMiniLiteral<"catalog">, z.ZodMiniLiteral<"catalogReferences">, z.ZodMiniLiteral<"cycles">]>>>;
     exclude: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"namespaceMembers">, z.ZodMiniLiteral<"catalog">, z.ZodMiniLiteral<"catalogReferences">, z.ZodMiniLiteral<"cycles">]>>>;
     workspaces: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
@@ -2191,6 +2202,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/configuration.js

@@ -2,10 +2,8 @@ import { z } from 'zod/mini';
 import { SYMBOL_TYPE } from '../constants.js';
 import { globSchema, pluginsSchema } from './plugins.js';
 const pathsSchema = z.record(z.string(), z.array(z.string()));
-const syncCompilerSchema = z.union([z.literal(true), z.custom()]);
-const asyncCompilerSchema = z.custom();
-const compilerSchema = z.union([syncCompilerSchema, asyncCompilerSchema]);
-const compilersSchema = z.record(z.string(), compilerSchema);
+const compilerSchema = z.custom();
+const compilersSchema = z.record(z.string(), z.union([z.literal(true), compilerSchema]));
 const stringOrRegexSchema = z.array(z.union([z.string(), z.instanceof(RegExp)]));
 const issueTypeSchema = z.union([
     z.literal('files'),
@@ -53,11 +51,12 @@ const rootConfigurationSchema = z.object({
     ignoreWorkspaces: z.optional(z.array(z.string())),
     includeEntryExports: z.optional(z.boolean()),
     compilers: z.optional(compilersSchema),
-    syncCompilers: z.optional(z.record(z.string(), syncCompilerSchema)),
-    asyncCompilers: z.optional(z.record(z.string(), asyncCompilerSchema)),
+    asyncCompilers: z.optional(z.record(z.string(), compilerSchema)),
     tags: z.optional(z.array(z.string())),
     treatConfigHintsAsErrors: z.optional(z.boolean()),
     treatTagHintsAsErrors: z.optional(z.boolean()),
+    preprocessor: z.optional(z.union([z.string(), z.array(z.string())])),
+    preprocessorOptions: z.optional(z.record(z.string(), z.unknown())),
 });
 const reportConfigSchema = z.object({
     include: z.optional(z.array(issueTypeSchema)),

package/dist/schema/plugins.d.ts

@@ -326,6 +326,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    mise: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     mocha: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -74,6 +74,7 @@ export const pluginsSchema = z.object({
     mdx: pluginSchema,
     mdxlint: pluginSchema,
     metro: pluginSchema,
+    mise: pluginSchema,
     mocha: pluginSchema,
     moonrepo: pluginSchema,
     msw: pluginSchema,

package/dist/session/index.d.ts

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
 export type { DependencyNode, DependencyNodes } from '../graph-explorer/operations/get-dependency-usage.ts';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.ts';
 export { getIssuePrefix } from '../reporters/util/util.ts';

package/dist/session/index.js

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
 export { getIssuePrefix } from '../reporters/util/util.js';
 export { createOptions } from '../util/create-options.js';

package/dist/session/session.js

@@ -1,18 +1,36 @@
 import { run } from '../run.js';
+import { createPreprocessor, toReporterOptions } from '../util/preprocessor.js';
 import { buildFileDescriptor } from './file-descriptor.js';
 import { buildPackageJsonDescriptor } from './package-json-descriptor.js';
 export const createSession = async (options) => {
     const { session, results } = await run(options);
     if (!session)
         throw new Error('Unable to initialize watch session');
-    return createSessionAdapter(session, results, options);
-};
-const createSessionAdapter = (session, results, options) => {
-    return {
+    const adapter = {
         handleFileChanges: session.handleFileChanges,
         getIssues: session.getIssues,
         getResults: () => results,
         describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
         describePackageJson: () => buildPackageJsonDescriptor(session.getGraph(), session.getEntryPaths()),
     };
+    if (options.preprocessor.length === 0)
+        return adapter;
+    const input = toReporterOptions(options, results);
+    const preprocess = await createPreprocessor(options.preprocessor);
+    const updateResults = async () => {
+        const data = await preprocess({ ...input, ...structuredClone(session.getIssues()) });
+        results.issues = data.issues;
+        results.counters = data.counters;
+        results.tagHints = data.tagHints;
+        results.configurationHints = data.configurationHints;
+    };
+    await updateResults();
+    adapter.handleFileChanges = async (changes) => {
+        const update = await session.handleFileChanges(changes);
+        if (update)
+            await updateResults();
+        return update;
+    };
+    adapter.getIssues = () => results;
+    return adapter;
 };