knip 6.35.1 → 6.37.0

package/dist/plugins/mise/scripts.js

@@ -2,11 +2,11 @@ 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 { isPackageManager } 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 { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
 import { walkCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
@@ -62,10 +62,10 @@ export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
                 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 isPackageCommand = isPackageManager(binary);
+                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
                 const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageManager && isWrapper(binary);
+                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
                 if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
                     continue;
                 let commandInputs;

package/dist/plugins/next/index.js

@@ -1,6 +1,8 @@
-import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { Visitor } from 'oxc-parser';
+import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isDirectory } from '../../util/fs.js';
-import { toConfig, toProductionEntry } from '../../util/input.js';
+import { toConfig, toDeferResolve, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Next.js';
@@ -38,10 +40,42 @@ const getEntryFilePatterns = (pageExtensions = defaultPageExtensions, cwd) => {
 };
 const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
-    const pageExtensions = [...collectPropertyValues(program, 'pageExtensions')];
-    const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
+    const pageExtensions = new Set();
+    const loaders = new Set();
+    const collectLoaders = (node) => {
+        if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                collectLoaders(element);
+        }
+        else {
+            const loader = getStringValue(node) ?? getStringValue(findProperty(node, 'loader'));
+            if (loader)
+                loaders.add(loader);
+            const nested = findProperty(node, 'loaders');
+            if (nested?.type === 'ArrayExpression')
+                collectLoaders(nested);
+        }
+    };
+    const visitor = new Visitor({
+        ObjectExpression(node) {
+            for (const extension of getPropertyValues(node, 'pageExtensions'))
+                pageExtensions.add(extension);
+            const rules = findProperty(findProperty(node, 'turbopack'), 'rules');
+            if (rules?.type !== 'ObjectExpression')
+                return;
+            for (const rule of rules.properties) {
+                if (rule.type === 'Property')
+                    collectLoaders(rule.value);
+            }
+        },
+    });
+    visitor.visit(program);
+    const extensions = pageExtensions.size > 0 ? [...pageExtensions] : defaultPageExtensions;
     const patterns = [...getEntryFilePatterns(extensions, configFileDir), 'next-env.d.ts'];
-    return patterns.map(id => toProductionEntry(join(configFileDir, id)));
+    const inputs = patterns.map(id => toProductionEntry(join(configFileDir, id)));
+    for (const loader of loaders)
+        inputs.push(toDeferResolve(loader));
+    return inputs;
 };
 const commands = new Set(['dev', 'build', 'start']);
 const args = {

package/dist/plugins/node/index.js

@@ -38,12 +38,18 @@ const args = {
     resolve: ['test-reporter'],
     boolean: [
         'deprecation',
+        'enable-source-maps',
+        'experimental-detect-module',
+        'experimental-json-modules',
         'experimental-strip-types',
         'experimental-transform-types',
+        'experimental-vm-modules',
+        'expose-gc',
         'harmony',
         'inspect-brk',
         'inspect-wait',
         'inspect',
+        'openssl-legacy-provider',
         'test-only',
         'test',
         'warnings',

package/dist/plugins/tailwind/compiler.js

@@ -1,5 +1,5 @@
+import { hasUrlScheme } from '../../util/url.js';
 const directiveMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:(?:import|config|plugin)\s+['"]([^'"]+)['"]|import\s+url\(\s*(?:['"]([^'"]+)['"]|([^'")\s]+))\s*\))[^;]*;/g;
-const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
 const compiler = (text) => {
     if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin'))
         return '';
@@ -10,7 +10,7 @@ const compiler = (text) => {
     while ((match = directiveMatcher.exec(text))) {
         const url = match[2] ?? match[3];
         const specifier = match[1] ?? url;
-        if (!specifier || (url && (url.startsWith('//') || urlSchemeMatcher.test(url))))
+        if (!specifier || (url && (url.startsWith('//') || hasUrlScheme(url))))
             continue;
         imports.push(`import _$${index++} from '${specifier}';`);
     }

package/dist/plugins/tailwind/index.js

@@ -2,7 +2,13 @@ import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import compiler from './compiler.js';
 const title = 'Tailwind';
-const enablers = ['tailwindcss', '@tailwindcss/vite', '@tailwindcss/postcss', '@tailwindcss/cli'];
+const enablers = [
+    'tailwindcss',
+    '@tailwindcss/vite',
+    '@tailwindcss/webpack',
+    '@tailwindcss/postcss',
+    '@tailwindcss/cli',
+];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts,cts,mts}'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {

package/dist/plugins/taskfile/index.js

@@ -97,7 +97,7 @@ const resolveConfig = async (localConfig, options) => {
         for (const task of Object.values(localConfig.tasks)) {
             for (const script of extractScriptsFromTask(task)) {
                 for (const input of getInputsFromScripts([script], {
-                    knownBinsOnly: true,
+                    optionalBinaries: true,
                     containingFilePath: configFilePath,
                 })) {
                     if (isProduction)

package/dist/plugins/tauri/index.js

@@ -26,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
             continue;
         const dir = typeof command === 'string' || !command.cwd ? options.cwd : join(options.cwd, command.cwd);
         const manifest = options.getManifest(dir) ?? options.manifest;
-        for (const input of options.getInputsFromScripts(script, { knownBinsOnly: true, cwd: dir, manifest })) {
+        for (const input of options.getInputsFromScripts(script, { optionalBinaries: true, cwd: dir, manifest })) {
             inputs.push({ ...input, dir });
         }
     }

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

@@ -0,0 +1,4 @@
+import type { Manifest } from '../../util/package-json.ts';
+export declare const toRuleDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;
+export declare const toFilterRuleDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;
+export declare const toPluginDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;

package/dist/plugins/textlint/helpers.js

@@ -0,0 +1,39 @@
+import { toDependency, toDeferResolveEntry } from '../../util/input.js';
+import { isInternal, toAbsolute } from '../../util/path.js';
+const RULE_PREFIX = 'textlint-rule-';
+const PRESET_PREFIX = 'textlint-rule-preset-';
+const FILTER_RULE_PREFIX = 'textlint-filter-rule-';
+const PLUGIN_PREFIX = 'textlint-plugin-';
+const createFullPackageName = (prefix, name) => {
+    if (name.charAt(0) === '@') {
+        const scopedName = name.slice(name.indexOf('/') + 1);
+        if (scopedName !== prefix && !scopedName.startsWith(`${prefix}-`)) {
+            return name.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}$2`);
+        }
+    }
+    return `${prefix}${name}`;
+};
+const hasPrefix = (prefix, name) => (name.charAt(0) === '@' ? name.slice(name.indexOf('/') + 1) : name).startsWith(prefix);
+const isDeclared = (manifest, name) => Boolean(manifest.dependencies?.[name] ??
+    manifest.devDependencies?.[name] ??
+    manifest.optionalDependencies?.[name] ??
+    manifest.peerDependencies?.[name]);
+const toPackageDependency = (prefix, name, candidates, manifest) => toDependency(candidates.find(candidate => isDeclared(manifest, candidate)) ??
+    (hasPrefix(prefix, name) ? name : createFullPackageName(prefix, name)));
+const isPresetRuleKey = (key) => key.startsWith('preset-') ||
+    key.startsWith(PRESET_PREFIX) ||
+    (key.charAt(0) === '@' && (key.includes('/preset-') || key.includes(`/${PRESET_PREFIX}`)));
+const toPresetDependency = (key, manifest) => {
+    const name = key.replace(/^preset-/, '').replace(/^@([^/]+)\/preset-(.*)$/, '@$1/$2');
+    const candidates = [`${PRESET_PREFIX}${name}`, name, createFullPackageName(PRESET_PREFIX, name), key];
+    return toPackageDependency(PRESET_PREFIX, name, candidates, manifest);
+};
+const toModuleDependency = (prefix, key, manifest) => toPackageDependency(prefix, key, [createFullPackageName(prefix, key), key], manifest);
+const toLocalEntry = (key, cwd) => toDeferResolveEntry(toAbsolute(key, cwd));
+export const toRuleDependency = (key, manifest, cwd) => {
+    if (isInternal(key))
+        return toLocalEntry(key, cwd);
+    return isPresetRuleKey(key) ? toPresetDependency(key, manifest) : toModuleDependency(RULE_PREFIX, key, manifest);
+};
+export const toFilterRuleDependency = (key, manifest, cwd) => isInternal(key) ? toLocalEntry(key, cwd) : toModuleDependency(FILTER_RULE_PREFIX, key, manifest);
+export const toPluginDependency = (key, manifest, cwd) => isInternal(key) ? toLocalEntry(key, cwd) : toModuleDependency(PLUGIN_PREFIX, key, manifest);

package/dist/plugins/textlint/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/textlint/index.js

@@ -0,0 +1,52 @@
+import { isInternal } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { toFilterRuleDependency, toPluginDependency, toRuleDependency } from './helpers.js';
+const title = 'textlint';
+const enablers = ['textlint'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'textlint';
+const config = ['package.json', '.textlintrc', '.textlintrc.{json,yaml,yml,js,cjs}'];
+const resolveConfig = (config, { cwd, manifest }) => {
+    const inputs = [];
+    for (const [key, options] of Object.entries(config.rules ?? {})) {
+        if (options)
+            inputs.push(toRuleDependency(key, manifest, cwd));
+    }
+    for (const key of Object.keys(config.filters ?? {}))
+        inputs.push(toFilterRuleDependency(key, manifest, cwd));
+    const plugins = Array.isArray(config.plugins) ? config.plugins : Object.keys(config.plugins ?? {});
+    for (const key of plugins)
+        inputs.push(toPluginDependency(key, manifest, cwd));
+    return inputs;
+};
+const toList = (value) => [value ?? []]
+    .flat()
+    .flatMap(item => String(item).split(','))
+    .map(item => item.trim())
+    .filter(Boolean);
+const args = {
+    config: true,
+    string: ['rule', 'preset', 'plugin'],
+    resolveInputs: (parsed, { cwd, manifest }) => {
+        const inputs = [];
+        for (const rule of toList(parsed.rule))
+            inputs.push(toRuleDependency(rule, manifest, cwd));
+        for (const preset of toList(parsed.preset)) {
+            const key = isInternal(preset) || preset.includes('preset-') ? preset : `preset-${preset}`;
+            inputs.push(toRuleDependency(key, manifest, cwd));
+        }
+        for (const plugin of toList(parsed.plugin))
+            inputs.push(toPluginDependency(plugin, manifest, cwd));
+        return inputs;
+    },
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    packageJsonPath,
+    config,
+    resolveConfig,
+    args,
+};
+export default plugin;

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

@@ -0,0 +1,5 @@
+export type TextlintConfig = {
+    rules?: Record<string, unknown>;
+    filters?: Record<string, unknown>;
+    plugins?: string[] | Record<string, unknown>;
+};

package/dist/plugins/textlint/types.js

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

package/dist/plugins/travis/index.js

@@ -11,7 +11,7 @@ const resolveConfig = async (config, options) => {
     const beforeInstall = config.before_install ?? [];
     const beforeScript = config.before_script ?? [];
     const scripts = [beforeDeploy, beforeInstall, beforeScript].flat();
-    return options.getInputsFromScripts(scripts, { knownBinsOnly: true });
+    return options.getInputsFromScripts(scripts, { optionalBinaries: true });
 };
 const plugin = {
     title,

package/dist/plugins/typedoc/index.js

@@ -1,3 +1,4 @@
+import { arrayify } from '../../util/array.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -15,8 +16,8 @@ const config = [
 ];
 const resolveConfig = (config, options) => {
     const cfg = 'typedocOptions' in config ? config.typedocOptions : config;
-    const plugins = cfg?.plugin ?? [];
-    const themes = cfg?.theme ?? [];
+    const plugins = arrayify(cfg?.plugin);
+    const themes = arrayify(cfg?.theme);
     const inputs = [...plugins, ...themes].map(id => toDeferResolve(id));
     for (const file of [cfg?.customCss, cfg?.customJs]) {
         if (file)

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

@@ -1,6 +1,6 @@
 export type TypeDocConfig = {
-    plugin?: string[];
-    theme?: string[];
+    plugin?: string | string[];
+    theme?: string | string[];
     customCss?: string;
     customJs?: string;
 };

package/dist/plugins/varlock/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/varlock/index.js

@@ -0,0 +1,31 @@
+import { arrayify } from '../../util/array.js';
+import { get } from '../../util/object.js';
+import { hasDependency } from '../../util/plugin.js';
+import { scanVarlockFiles } from './scan.js';
+const title = 'Varlock';
+const enablers = ['varlock'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const getLoadPaths = (manifest) => arrayify(get(manifest, 'varlock.loadPath'));
+const resolve = options => {
+    const loadPaths = getLoadPaths(options.manifest);
+    return scanVarlockFiles(loadPaths.length > 0 ? loadPaths : ['.'], options.cwd);
+};
+const args = {
+    alias: { path: ['p'] },
+    string: ['path', 'env'],
+    fromArgs: parsed => (parsed._[0] === 'run' ? (parsed['--'] ?? []) : []),
+    resolveInputs: (parsed, { cwd, manifest }) => {
+        const paths = arrayify(parsed.path);
+        const loadPaths = getLoadPaths(manifest);
+        const environment = arrayify(parsed.env).at(-1);
+        return scanVarlockFiles(paths.length > 0 ? paths : environment ? (loadPaths.length > 0 ? loadPaths : ['.']) : [], cwd);
+    },
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    args,
+    resolve,
+};
+export default plugin;

package/dist/plugins/varlock/parse.d.ts

@@ -0,0 +1,11 @@
+type Directive = {
+    name: 'import' | 'plugin';
+    descriptor: string;
+    enabled?: boolean | null;
+    allowMissing?: boolean | null;
+};
+export declare const parseVarlockFile: (source: string) => {
+    directives: Directive[];
+    disabled: boolean;
+};
+export {};

package/dist/plugins/varlock/parse.js

@@ -0,0 +1,185 @@
+const pairs = { '(': ')', '[': ']', '{': '}' };
+const getRootComments = (source) => {
+    const comments = [];
+    let block = [];
+    let hasConfigItem = false;
+    for (const line of source.replace(/^\uFEFF/, '').split(/\r?\n/)) {
+        if (!line.trim()) {
+            comments.push(...block);
+            block = [];
+            continue;
+        }
+        const match = line.match(/^\s*#(.*)$/);
+        if (!match) {
+            hasConfigItem = true;
+            break;
+        }
+        const content = match[1].trimStart();
+        if (/^[-=*#]{3}/.test(content)) {
+            comments.push(...block);
+            block = [];
+        }
+        else {
+            block.push(content);
+        }
+    }
+    if (!hasConfigItem)
+        comments.push(...block);
+    return comments.join('\n');
+};
+const readQuoted = (value, start) => {
+    const quote = value[start];
+    let result = '';
+    for (let index = start + 1; index < value.length; index++) {
+        const char = value[index];
+        if (char === quote)
+            return { value: result, end: index + 1 };
+        if (char === '\\' && value[index + 1] === quote) {
+            result += quote;
+            index++;
+        }
+        else {
+            result += char;
+        }
+    }
+};
+const readArguments = (value, start) => {
+    const args = [];
+    const stack = [pairs[value[start]]];
+    let argument = '';
+    for (let index = start + 1; index < value.length; index++) {
+        const char = value[index];
+        if (char === '"' || char === "'" || char === '`') {
+            const quoted = readQuoted(value, index);
+            if (!quoted)
+                return;
+            argument += value.slice(index, quoted.end);
+            index = quoted.end - 1;
+        }
+        else if (char === '#') {
+            index = value.indexOf('\n', index);
+            if (index === -1)
+                return;
+            argument += ' ';
+        }
+        else if (pairs[char]) {
+            stack.push(pairs[char]);
+            argument += char;
+        }
+        else if (char === stack.at(-1)) {
+            stack.pop();
+            if (stack.length === 0) {
+                args.push(argument.trim());
+                return { args, end: index + 1 };
+            }
+            argument += char;
+        }
+        else if (char === ',' && stack.length === 1) {
+            args.push(argument.trim());
+            argument = '';
+        }
+        else {
+            argument += char;
+        }
+    }
+};
+const readValueEnd = (value, start) => {
+    let index = start;
+    while (index < value.length && !/[\s#]/.test(value[index])) {
+        const char = value[index];
+        if (char === '"' || char === "'" || char === '`') {
+            const quoted = readQuoted(value, index);
+            if (!quoted)
+                return value.length;
+            index = quoted.end;
+        }
+        else if (pairs[char]) {
+            const nested = readArguments(value, index);
+            if (!nested)
+                return value.length;
+            index = nested.end;
+        }
+        else {
+            index++;
+        }
+    }
+    return index;
+};
+const getStaticString = (value) => {
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if (quote === '"' || quote === "'" || quote === '`') {
+        const quoted = readQuoted(trimmed, 0);
+        return quoted?.end === trimmed.length ? quoted.value : undefined;
+    }
+    if (!trimmed || /[\s,)]/.test(trimmed) || trimmed.includes('$') || /^[a-z][a-z\d_]*\(/i.test(trimmed))
+        return;
+    if (/^(?:true|false|undefined)$/i.test(trimmed))
+        return;
+    const number = Number(trimmed);
+    return Number.isFinite(number) && String(number) === trimmed ? undefined : trimmed;
+};
+const getBoolean = (value) => {
+    const trimmed = value.trim();
+    return trimmed === 'true' ? true : trimmed === 'false' ? false : null;
+};
+export const parseVarlockFile = (source) => {
+    const directives = [];
+    const value = getRootComments(source);
+    let disabled = false;
+    for (let index = 0; index < value.length;) {
+        while (value[index] === ' ' || value[index] === '\t')
+            index++;
+        if (value[index] !== '@') {
+            index = value.indexOf('\n', index) + 1 || value.length;
+            continue;
+        }
+        while (index < value.length && value[index] !== '\n' && value[index] !== '#') {
+            if (value[index] !== '@' || !/[a-z]/i.test(value[index + 1] ?? '')) {
+                index++;
+                continue;
+            }
+            let nameEnd = index + 2;
+            while (/[a-z\d_]/i.test(value[nameEnd] ?? ''))
+                nameEnd++;
+            const name = value.slice(index + 1, nameEnd);
+            let cursor = nameEnd;
+            while (value[cursor] === ' ' || value[cursor] === '\t')
+                cursor++;
+            if (value[cursor] === '(') {
+                const result = readArguments(value, cursor);
+                if (!result)
+                    break;
+                if (name === 'plugin' || name === 'import') {
+                    const descriptor = getStaticString(result.args[0] ?? '');
+                    if (descriptor !== undefined) {
+                        const directive = { name, descriptor };
+                        for (const arg of result.args.slice(1)) {
+                            const separator = arg.indexOf('=');
+                            if (separator === -1)
+                                continue;
+                            const key = arg.slice(0, separator).trim();
+                            if (key === 'enabled' || key === 'allowMissing')
+                                directive[key] = getBoolean(arg.slice(separator + 1));
+                        }
+                        directives.push(directive);
+                    }
+                }
+                index = result.end;
+            }
+            else if (value[cursor] === '=') {
+                const end = readValueEnd(value, cursor + 1);
+                if (name === 'disable')
+                    disabled ||= getBoolean(value.slice(cursor + 1, end)) === true;
+                index = end;
+            }
+            else {
+                if (name === 'disable')
+                    disabled = true;
+                index = nameEnd;
+            }
+        }
+        index = value.indexOf('\n', index) + 1 || value.length;
+    }
+    return { directives, disabled };
+};

package/dist/plugins/varlock/scan.d.ts

@@ -0,0 +1,2 @@
+import type { Input } from '../../util/input.ts';
+export declare const scanVarlockFiles: (paths: string[], cwd: string) => Input[];

package/dist/plugins/varlock/scan.js

@@ -0,0 +1,78 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { toDeferResolve, toDeferResolveProductionEntry, toDependency } from '../../util/input.js';
+import { isDirectory, isFile, tryRealpath } from '../../util/fs.js';
+import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
+import { dirname, isInternal, join, toAbsolute } from '../../util/path.js';
+import { isGitIgnored } from '../../util/glob-core.js';
+import { debugLog } from '../../util/debug.js';
+import { hasUrlScheme } from '../../util/url.js';
+import { parseVarlockFile } from './parse.js';
+const resolvePath = (path, cwd) => path.startsWith('~/') ? join(homedir(), path.slice(2)) : toAbsolute(path, cwd);
+const isExternalUrl = (path) => path.startsWith('//') || hasUrlScheme(path);
+const isLocalPath = (path) => path.startsWith('~/') || isInternal(path);
+const expandLoadPath = (path) => {
+    if (!isDirectory(path))
+        return [path];
+    try {
+        const paths = [];
+        for (const name of readdirSync(path))
+            if (name === '.env' || name.startsWith('.env.'))
+                paths.push(join(path, name));
+        return paths;
+    }
+    catch {
+        return [];
+    }
+};
+export const scanVarlockFiles = (paths, cwd) => {
+    const inputs = [];
+    const queue = [];
+    for (const path of paths)
+        queue.push(...expandLoadPath(resolvePath(path, cwd)));
+    const visited = new Set();
+    for (const path of queue) {
+        if (!isFile(path) || isGitIgnored(path))
+            continue;
+        const realPath = tryRealpath(path);
+        if (visited.has(realPath))
+            continue;
+        visited.add(realPath);
+        let source;
+        try {
+            source = readFileSync(realPath, 'utf8');
+        }
+        catch (error) {
+            debugLog('Varlock', `Unable to read ${realPath} (${error instanceof Error ? error.message : error})`);
+            continue;
+        }
+        const { directives, disabled } = parseVarlockFile(source);
+        if (disabled)
+            continue;
+        for (const { name, descriptor, enabled, allowMissing } of directives) {
+            if (!descriptor || descriptor.includes('$') || isExternalUrl(descriptor) || enabled === false)
+                continue;
+            if (name === 'plugin') {
+                if (isLocalPath(descriptor)) {
+                    inputs.push(toDeferResolveProductionEntry(descriptor.startsWith('~/') ? resolvePath(descriptor, dirname(realPath)) : descriptor, { containingFilePath: realPath }));
+                }
+                else {
+                    const packageName = getPackageNameFromModuleSpecifier(descriptor);
+                    if (packageName) {
+                        inputs.push({ ...toDependency(packageName, { containingFilePath: realPath }), production: true });
+                    }
+                }
+                continue;
+            }
+            if (!isLocalPath(descriptor))
+                continue;
+            const importPath = resolvePath(descriptor, dirname(realPath));
+            if (isFile(importPath) || isDirectory(importPath))
+                queue.push(...expandLoadPath(importPath));
+            else if (allowMissing !== true && allowMissing !== null && enabled !== null) {
+                inputs.push(toDeferResolve(descriptor, { containingFilePath: realPath }));
+            }
+        }
+    }
+    return inputs;
+};

package/dist/plugins/vite-plus/resolveFromAST.js

@@ -30,7 +30,7 @@ export const resolveFromAST = (program, options) => {
     visitor.visit(program);
     const inputs = [];
     for (const command of commands) {
-        for (const input of options.getInputsFromScripts(command, { knownBinsOnly: true }))
+        for (const input of options.getInputsFromScripts(command, { optionalBinaries: true }))
             inputs.push(input);
     }
     return inputs;

package/dist/plugins/vitest/index.js

@@ -143,7 +143,9 @@ export const resolveConfig = async (localConfig, options) => {
             for (const entry of await getIndexHtmlEntries(viteRoot, publicDir))
                 inputs.add(entry);
         }
-        const vitestRoot = toAbsolute(cfg.test?.root ?? '.', options.cwd);
+        const vitestRoot = cfg.test?.root || !options.isResolvedConfigFile
+            ? toAbsolute(cfg.test?.root ?? '.', options.cwd)
+            : toAbsolute('.', options.configFileDir);
         const dir = cfg.test?.dir ? toAbsolute(cfg.test.dir, vitestRoot) : vitestRoot;
         if (cfg.test) {
             if (cfg.test?.include) {
@@ -189,7 +191,7 @@ export const resolveConfig = async (localConfig, options) => {
             inputs.add(dependency);
         const _entry = cfg.build?.lib?.entry ?? [];
         const entries = typeof _entry === 'string' ? [_entry] : Array.isArray(_entry) ? _entry : Object.values(_entry).flat();
-        const deps = entries.map(specifier => join(vitestRoot, specifier)).map(id => toEntry(id));
+        const deps = entries.map(specifier => join(viteRoot, specifier)).map(id => toEntry(id));
         for (const dependency of deps)
             inputs.add(dependency);
     }