knip 6.33.0 → 6.35.0

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/node/index.js

@@ -1,5 +1,6 @@
 import { toEntry, toProductionEntry } from '../../util/input.js';
 import { getScriptCommands } from '../../util/scripts.js';
+import { createFsPromisesGlobVisitor } from './visitors/fsPromisesGlob.js';
 const title = 'Node.js';
 const isEnabled = () => true;
 const patterns = [
@@ -21,6 +22,9 @@ const hasNodeTest = (scripts) => {
     return result;
 };
 const entry = ['server.js'];
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createFsPromisesGlobVisitor(ctx));
+};
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));
     if (hasNodeTest(options.manifest.scripts) || hasNodeTest(options.rootManifest?.scripts)) {
@@ -53,5 +57,6 @@ const plugin = {
     entry,
     resolve,
     args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/node/visitors/fsPromisesGlob.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createFsPromisesGlobVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/node/visitors/fsPromisesGlob.js

@@ -0,0 +1,89 @@
+import { findProperty, getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+const FS_PROMISES = new Set(['node:fs/promises', 'fs/promises']);
+export function createFsPromisesGlobVisitor(ctx) {
+    const globNames = new Set();
+    const namespaceNames = new Set();
+    return {
+        Program() {
+            globNames.clear();
+            namespaceNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!FS_PROMISES.has(node.source.value))
+                return;
+            for (const specifier of node.specifiers ?? []) {
+                if (specifier.type === 'ImportNamespaceSpecifier') {
+                    namespaceNames.add(specifier.local.name);
+                }
+                else if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported.type === 'Identifier' &&
+                    specifier.imported.name === 'glob') {
+                    globNames.add(specifier.local.name);
+                }
+            }
+        },
+        VariableDeclarator(node) {
+            if (node.init?.type !== 'CallExpression' ||
+                node.init.callee.type !== 'Identifier' ||
+                node.init.callee.name !== 'require' ||
+                !isStringLiteral(node.init.arguments[0]) ||
+                !FS_PROMISES.has(getStringValue(node.init.arguments[0])))
+                return;
+            if (node.id.type === 'Identifier') {
+                namespaceNames.add(node.id.name);
+            }
+            else if (node.id.type === 'ObjectPattern') {
+                for (const property of node.id.properties) {
+                    if (property.type === 'Property' &&
+                        getPropertyKey(property) === 'glob' &&
+                        property.value.type === 'Identifier') {
+                        globNames.add(property.value.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            let isGlobCall = node.callee.type === 'Identifier' && globNames.has(node.callee.name);
+            if (!isGlobCall &&
+                node.callee.type === 'MemberExpression' &&
+                !node.callee.computed &&
+                node.callee.object.type === 'Identifier' &&
+                namespaceNames.has(node.callee.object.name) &&
+                node.callee.property.type === 'Identifier' &&
+                node.callee.property.name === 'glob') {
+                isGlobCall = true;
+            }
+            if (!isGlobCall)
+                return;
+            const arg = node.arguments[0];
+            if (!arg)
+                return;
+            let patterns;
+            if (isStringLiteral(arg)) {
+                patterns = [getStringValue(arg)];
+            }
+            else if (arg.type === 'ArrayExpression') {
+                patterns = [];
+                for (const element of arg.elements) {
+                    if (!element || !isStringLiteral(element))
+                        return;
+                    patterns.push(getStringValue(element));
+                }
+            }
+            if (!patterns?.length || patterns.some(pattern => pattern.startsWith('!')))
+                return;
+            const options = node.arguments[1];
+            if (options && options.type !== 'ObjectExpression')
+                return;
+            if (options &&
+                (options.properties.length > 1 ||
+                    options.properties.some(property => property.type !== 'Property' || property.computed || getPropertyKey(property) !== 'cwd')))
+                return;
+            const cwdNode = findProperty(options, 'cwd');
+            if (cwdNode && !isStringLiteral(cwdNode))
+                return;
+            ctx.addImportGlob(patterns, { cwd: cwdNode ? getStringValue(cwdNode) : '.' });
+        },
+    };
+}

package/dist/plugins/nuxt/index.js

@@ -87,18 +87,18 @@ const addAppEntries = (inputs, srcDir, serverDir, config, dir) => {
             inputs.push(toDeferResolveProductionEntry(resolveAlias(id, srcDir, dir)));
 };
 const findLayerConfigs = (cwd) => _syncGlob({ cwd, patterns: [`layers/*/${config.at(0)}`] });
+const definitionFiles = [
+    '.nuxt/imports.d.ts',
+    '.nuxt/components.d.ts',
+    '.nuxt/types/nitro-routes.d.ts',
+    '.nuxt/types/nitro-imports.d.ts',
+];
 const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
-    if (hasDependency('nuxt') || hasDependency('nuxt-nightly')) {
+    if (hasDependency('nuxt') || hasDependency('nuxt-nightly') || isDirectory(cwd, '.nuxt')) {
+        const paths = definitionFiles.map(file => join(cwd, file));
         const maps = createAutoImportMaps();
-        const definitionFiles = [
-            '.nuxt/imports.d.ts',
-            '.nuxt/components.d.ts',
-            '.nuxt/types/nitro-routes.d.ts',
-            '.nuxt/types/nitro-imports.d.ts',
-        ];
-        for (const file of definitionFiles) {
-            const path = join(cwd, file);
-            buildAutoImportMap(path, readAndParseFile(path), maps, file.endsWith('components.d.ts'));
+        for (const path of paths) {
+            buildAutoImportMap(path, readAndParseFile(path), maps, path.endsWith('components.d.ts'));
         }
         registerCompiler({ extension: '.vue', compiler: createVueCompiler(maps, cwd) });
         registerCompiler({ extension: '.ts', compiler: createTsCompiler(maps) });
@@ -121,6 +121,9 @@ const resolveConfig = async (localConfig, options) => {
             addModule(id);
     }
     addAppEntries(inputs, srcDir, serverDir, localConfig, cwd);
+    const sharedDir = toAbsolute(localConfig.dir?.shared ?? 'shared', cwd);
+    inputs.push(toAlias('#shared', sharedDir));
+    inputs.push(toAlias('#shared/*', join(sharedDir, '*'), { dir: cwd }));
     const aliases = localConfig.alias;
     if (aliases) {
         for (const key in aliases) {

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/run.js

@@ -60,7 +60,7 @@ export const run = async (options) => {
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
     const findWorkspacePackageTarget = getWorkspacePackageTargetHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget, filePath => chief.findWorkspaceByFilePath(filePath)?.name);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setSelectedWorkspaces(chief.selectedWorkspaces);
     collector.setIgnoreIssues(chief.getIgnoreIssues());

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)),