knip 6.41.0 → 6.42.0

package/dist/plugins/mise/scripts.js

@@ -1,4 +1,4 @@
-import { parse } from 'unbash';
+import { forEachChild, parse } from 'unbash';
 import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
 import { spawningBinaries } from '../../binaries/fallback.js';
 import { isWrapper } from '../../binaries/plugins.js';
@@ -7,121 +7,79 @@ import { toScript } from '../../binaries/util.js';
 import { SCRIPT_INTERPOLATION } from '../../constants.js';
 import { isBinary } from '../../util/input.js';
 import { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
-import { walkCommands } from '../../util/scripts.js';
+import { isScriptExpansion, collectCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
     const definedFunctions = new Set();
-    const readParts = (parts) => {
+    const readCommand = (command, source) => {
         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;
+        let cursor = command.pos;
+        const visit = (node) => {
+            if (!isScriptExpansion(node)) {
+                forEachChild(node, visit);
+                return;
             }
-            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;
+            if (node.script)
+                readScript(node.script, node.script.source ?? source);
+            if (node.pos >= cursor && node.end <= command.end) {
+                text += source.slice(cursor, node.pos) + SCRIPT_INTERPOLATION;
+                cursor = node.end;
             }
-            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 ? { type: 'Word', pos: word.pos, end: word.end, text, value } : word;
-    };
-    const readAssignment = (assignment) => {
-        const original = assignment.value;
-        const value = original.type === 'Word'
-            ? readWord(original)
-            : { type: 'ArrayValue', pos: original.pos, end: original.end, elements: original.elements.map(readWord) };
-        if (value === original)
-            return assignment;
-        const text = value.type === 'Word' ? value.text : `(${value.elements.map(word => word.text).join(' ')})`;
-        return {
-            type: 'Assignment',
-            pos: assignment.pos,
-            end: assignment.end,
-            name: assignment.name,
-            index: assignment.index,
-            append: assignment.append,
-            value,
-            text: assignment.text.slice(0, original.pos - assignment.pos) + text,
         };
+        forEachChild(command, visit);
+        return text + source.slice(cursor, command.end);
     };
-    const readScript = (parsed) => {
+    const readScript = (parsed, source) => {
         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
-                    .filter((item) => item.type === 'Assignment')
-                    .map(readAssignment);
-                const words = [];
-                for (const arg of command.args) {
-                    if (arg.type === 'Word')
-                        words.push(readWord(arg));
-                    else
-                        readAssignment(arg);
-                }
-                if (!name || !word || definedFunctions.has(name))
+        for (const command of collectCommands(parsed)) {
+            const text = readCommand(command, source);
+            const name = command.name?.value;
+            if (!name || definedFunctions.has(name))
+                continue;
+            const binary = extractBinary(name);
+            const isPackageCommand = isPackageManager(binary);
+            const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
+            const hasPath = command.prefix.some(item => item.type === 'Assignment' && item.name === 'PATH');
+            const isLocal = hasLocalBinPath && !hasPath;
+            const isWrapperCommand = !isPackageCommand && isWrapper(binary);
+            if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                continue;
+            let commandInputs;
+            if (isWrapperCommand || binary === 'find') {
+                const [marked] = collectCommands(parse(text));
+                if (!marked)
                     continue;
-                const binary = extractBinary(name);
-                const isPackageCommand = isPackageManager(binary);
-                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
-                const isLocal = hasLocalBinPath && !prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
-                if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                const fromScript = (script) => {
+                    inputs.push(...getInputsFromMiseScript(script, options, isLocal));
+                    return [];
+                };
+                const fromArgs = args => fromScript(toScript(args));
+                commandInputs = getDependenciesFromCommand(marked, { ...options, fromArgs });
+                if (spawningBinaries.includes(binary))
+                    commandInputs.push(...getInputsFromNodeOptions(marked.prefix));
+            }
+            else {
+                commandInputs = options.getInputsFromScripts(text, { cwd: options.cwd, manifest: options.manifest });
+            }
+            if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                continue;
+            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;
-                let commandInputs;
-                if (isWrapperCommand || binary === 'find') {
-                    const fromScript = (script) => {
-                        inputs.push(...getInputsFromMiseScript(script, options, isLocal));
-                        return [];
-                    };
-                    const fromArgs = args => fromScript(toScript(args));
-                    commandInputs = getDependenciesFromCommand({ name: word, prefix, args: 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')
+                if (!isExplicit && !isLocal && input === binaryInput)
                     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);
-                }
+                inputs.push(input);
             }
         }
     };
     try {
-        readScript(parse(script));
+        readScript(parse(script), script);
     }
     catch {
         return [];

package/dist/plugins/next/index.js

@@ -42,6 +42,28 @@ const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
     const pageExtensions = new Set();
     const loaders = new Set();
+    const aliasTargets = new Set();
+    const collectAliasTargets = (node) => {
+        const target = getStringValue(node);
+        if (target)
+            aliasTargets.add(target);
+        else if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                collectAliasTargets(element);
+        }
+        else if (node?.type === 'ObjectExpression') {
+            collectAliasTargets(findProperty(node, 'browser'));
+        }
+    };
+    const collectTurbopackAliases = (node) => {
+        const aliases = findProperty(node, 'resolveAlias');
+        if (aliases?.type !== 'ObjectExpression')
+            return;
+        for (const alias of aliases.properties) {
+            if (alias.type === 'Property')
+                collectAliasTargets(alias.value);
+        }
+    };
     const collectLoaders = (node) => {
         if (node?.type === 'ArrayExpression') {
             for (const element of node.elements)
@@ -60,7 +82,15 @@ const resolveFromAST = (program, { configFileDir }) => {
         ObjectExpression(node) {
             for (const extension of getPropertyValues(node, 'pageExtensions'))
                 pageExtensions.add(extension);
-            const rules = findProperty(findProperty(node, 'turbopack'), 'rules');
+            const turbopack = findProperty(node, 'turbopack');
+            if (turbopack?.type === 'ConditionalExpression') {
+                collectTurbopackAliases(turbopack.consequent);
+                collectTurbopackAliases(turbopack.alternate);
+            }
+            else {
+                collectTurbopackAliases(turbopack);
+            }
+            const rules = findProperty(turbopack, 'rules');
             if (rules?.type !== 'ObjectExpression')
                 return;
             for (const rule of rules.properties) {
@@ -75,6 +105,8 @@ const resolveFromAST = (program, { configFileDir }) => {
     const inputs = patterns.map(id => toProductionEntry(join(configFileDir, id)));
     for (const loader of loaders)
         inputs.push(toDeferResolve(loader));
+    for (const target of aliasTargets)
+        inputs.push({ ...toDeferResolve(target, { dir: configFileDir }), production: true });
     return inputs;
 };
 const commands = new Set(['dev', 'build', 'start']);

package/dist/plugins/nx/index.js

@@ -1,6 +1,8 @@
 import { compact } from '../../util/array.js';
-import { toConfig, toDependency } from '../../util/input.js';
-import { join, relative } from '../../util/path.js';
+import { isFile, loadJSON } from '../../util/fs.js';
+import { toConfig, toDeferResolveEntry, toDependency } from '../../util/input.js';
+import { get } from '../../util/object.js';
+import { dirname, join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { substringBefore } from '../../util/string.js';
 const title = 'Nx';
@@ -57,32 +59,67 @@ const resolveConfig = async (localConfig, options) => {
         const expandRelative = (command) => command
             .replaceAll('{projectRoot}', relative(cwd, options.configFileDir))
             .replaceAll('{workspaceRoot}', relative(cwd, options.rootCwd));
-        return options.getInputsFromScripts(commands.map(expandRelative), { cwd });
+        const scriptInputs = options.getInputsFromScripts(commands.map(expandRelative), { cwd });
+        for (const input of scriptInputs)
+            input.dir ??= cwd;
+        return scriptInputs;
     });
+    const toTargetConfig = (pluginName, specifier) => toConfig(pluginName, expand(specifier), { dir: options.rootCwd });
     const configInputs = targets.flatMap(target => {
         const opts = target.options;
         if (!opts)
             return [];
         const configs = [];
         if ('eslintConfig' in opts && typeof opts.eslintConfig === 'string') {
-            configs.push(toConfig('eslint', opts.eslintConfig));
+            configs.push(toTargetConfig('eslint', opts.eslintConfig));
         }
         if ('jestConfig' in opts && typeof opts.jestConfig === 'string') {
-            configs.push(toConfig('jest', opts.jestConfig));
+            configs.push(toTargetConfig('jest', opts.jestConfig));
+        }
+        if ('karmaConfig' in opts && typeof opts.karmaConfig === 'string') {
+            configs.push(toTargetConfig('karma', opts.karmaConfig));
         }
         if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
-            configs.push(toConfig('typescript', opts.tsConfig));
+            configs.push(toTargetConfig('typescript', opts.tsConfig));
         }
         if ('vitestConfig' in opts && typeof opts.vitestConfig === 'string') {
-            configs.push(toConfig('vitest', opts.vitestConfig));
+            configs.push(toTargetConfig('vitest', opts.vitestConfig));
         }
         if ('webpackConfig' in opts && typeof opts.webpackConfig === 'string') {
-            configs.push(toConfig('webpack', opts.webpackConfig));
+            configs.push(toTargetConfig('webpack', opts.webpackConfig));
         }
         return configs;
     });
     return compact([...executors, ...inputs, ...configInputs]).map(id => typeof id === 'string' ? toDependency(id) : id);
 };
+const collections = [
+    ['generators', 'schematics'],
+    ['executors', 'builders'],
+];
+const resolve = async (options) => {
+    const inputs = [];
+    for (const [key, alias] of collections) {
+        const file = get(options.manifest, key) ?? get(options.manifest, alias);
+        if (typeof file !== 'string')
+            continue;
+        const filePath = join(options.cwd, file);
+        if (!isFile(filePath))
+            continue;
+        const collection = await loadJSON(filePath);
+        for (const entries of [collection[key], collection[alias]]) {
+            for (const entry of Object.values(entries ?? {})) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                for (const id of [entry.implementation || entry.factory, entry.batchImplementation]) {
+                    if (typeof id === 'string' && id.length > 0) {
+                        inputs.push(toDeferResolveEntry(join(dirname(filePath), substringBefore(id, '#'))));
+                    }
+                }
+            }
+        }
+    }
+    return inputs;
+};
 const args = {
     fromArgs: (parsed) => (parsed._[0] === 'exec' ? [...parsed._.slice(1), ...(parsed['--'] ?? [])] : []),
 };
@@ -95,6 +132,7 @@ const plugin = {
     isEnabled,
     config,
     resolveConfig,
+    resolve,
     args,
 };
 export default plugin;

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

@@ -11,6 +11,7 @@ export interface NxProjectConfiguration {
                 cwd?: string;
                 eslintConfig?: string;
                 jestConfig?: string;
+                karmaConfig?: string;
                 tsConfig?: string;
                 vitestConfig?: string;
                 webpackConfig?: string;
@@ -18,6 +19,12 @@ export interface NxProjectConfiguration {
         };
     };
 }
+type NxCollectionEntry = string | {
+    factory?: string;
+    implementation?: string;
+    batchImplementation?: string;
+};
+export type NxCollection = Record<string, Record<string, NxCollectionEntry> | undefined>;
 export interface NxConfigRoot {
     plugins?: Array<string | {
         plugin: string;
@@ -25,3 +32,4 @@ export interface NxConfigRoot {
     generators?: Record<string, unknown>;
     targetDefaults?: Record<string, unknown>;
 }
+export {};

package/dist/plugins/oxlint/index.js

@@ -26,7 +26,7 @@ export const resolveExtendedConfig = (config, configFilePath) => {
     for (const entry of config.extends ?? []) {
         if (typeof entry === 'string') {
             const filePath = toAbsolute(entry, dirname(configFilePath));
-            inputs.push(toConfig('oxlint', filePath, { containingFilePath: configFilePath }));
+            inputs.push(toConfig('oxlint', filePath));
         }
         else {
             for (const input of resolveExtendedConfig(entry, configFilePath))

package/dist/plugins/react-router/index.d.ts

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

package/dist/plugins/react-router/index.js

@@ -43,6 +43,9 @@ const resolveConfig = async (localConfig, options) => {
     }
     return resolved;
 };
+const note = `Route modules import their types from \`./+types/<route>\`, which \`react-router typegen\` generates.
+Run \`react-router typegen\` before Knip (e.g. in CI or a fresh checkout), or these imports are reported as unresolved.`;
+export const docs = { note };
 const plugin = {
     title,
     enablers,

package/dist/plugins/rstest/index.js

@@ -91,7 +91,7 @@ const resolveConfig = async (localConfig, options) => {
                     .catch(() => undefined)
                 : undefined;
             if (!project) {
-                inputs.push(toConfig('rstest', filePath, { containingFilePath: configFilePath }));
+                inputs.push(toConfig('rstest', filePath));
                 continue;
             }
             inputs.push(toEntry(filePath));

package/dist/plugins/solidjs-vite-plugin/index.d.ts

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

package/dist/plugins/solidjs-vite-plugin/index.js

@@ -0,0 +1,17 @@
+import { hasDependency } from '../../util/plugin.js';
+import { config } from '../vite/index.js';
+import { production, resolveFromAST } from './resolveFromAST.js';
+const title = '@solidjs/vite-plugin';
+const enablers = ['@solidjs/vite-plugin'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const note = `Without a Vite config, the default entry patterns are used. With a config, start entries are only added when \`start\` is enabled. Paths like \`start.app\` replace the matching default, and the \`ssr\` option decides which files Solid loads. \`serverFunctions.configure\` is added with or without \`start\`.`;
+export const docs = { note };
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/solidjs-vite-plugin/resolveFromAST.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const production: string[];
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/solidjs-vite-plugin/resolveFromAST.js

@@ -0,0 +1,76 @@
+import { findImportedCalls, findProperty } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { isFile } from '../../util/fs.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join, toAbsolute } from '../../util/path.js';
+import { getViteRoot } from '../vite/helpers.js';
+const entryExtensions = ['tsx', 'jsx', 'ts', 'js', 'mjs', 'tsrx'];
+const entryStems = {
+    entryServer: 'src/entry-server',
+    entryClient: 'src/entry-client',
+};
+const conventions = {
+    entryServer: `src/entry-server.{${entryExtensions.join(',')}}`,
+    entryClient: `src/entry-client.{${entryExtensions.join(',')}}`,
+    app: 'src/{App,app}.{tsx,jsx,ts,js,tsrx}',
+    document: 'src/Document.{tsx,jsx,tsrx}',
+    env: 'env.{ts,js}',
+};
+export const production = Object.values(conventions);
+const startOptions = ['app', 'document', 'entryServer', 'entryClient', 'middleware', 'instrument', 'setup', 'env'];
+const isBoolean = (node, value) => node?.type === 'Literal' && node.value === value;
+const hasEntryFile = (root, stem) => {
+    for (const extension of entryExtensions)
+        if (isFile(root, `${stem}.${extension}`))
+            return true;
+    return false;
+};
+export const resolveFromAST = (program, options) => {
+    const root = getViteRoot(program, options.cwd);
+    const patterns = new Set();
+    const paths = new Set();
+    for (const call of findImportedCalls(program, '@solidjs/vite-plugin')) {
+        const arg = call.arguments[0];
+        if (arg?.type !== 'ObjectExpression')
+            continue;
+        const configure = getStringValue(findProperty(findProperty(arg, 'serverFunctions'), 'configure'));
+        if (configure)
+            paths.add(configure);
+        const start = findProperty(arg, 'start');
+        if (!start || isBoolean(start, false))
+            continue;
+        const values = {};
+        for (const name of startOptions) {
+            values[name] = start.type === 'ObjectExpression' ? findProperty(start, name) : undefined;
+        }
+        const isAuthored = (name) => Boolean(getStringValue(values[name])) || hasEntryFile(root, entryStems[name]);
+        const ssr = findProperty(arg, 'ssr');
+        const skip = new Set();
+        if (!ssr || isBoolean(ssr, false)) {
+            skip.add('entryServer');
+            skip.add('setup');
+            if (isAuthored('entryClient'))
+                skip.add('app');
+        }
+        else if (isBoolean(ssr, true) && isAuthored('entryServer') && isAuthored('entryClient')) {
+            skip.add('app');
+            skip.add('document');
+        }
+        for (const name of startOptions) {
+            if (skip.has(name))
+                continue;
+            const value = values[name];
+            const path = getStringValue(value);
+            if (path)
+                paths.add(path);
+            else if (name in conventions && !(name === 'env' && isBoolean(value, false)))
+                patterns.add(conventions[name]);
+        }
+    }
+    const inputs = [];
+    for (const pattern of patterns)
+        inputs.push(toProductionEntry(join(root, pattern)));
+    for (const id of paths)
+        inputs.push(toProductionEntry(toAbsolute(id, root)));
+    return inputs;
+};

package/dist/plugins/sst/resolveFromAST.js

@@ -44,5 +44,5 @@ export const resolveFromAST = (program, options) => {
         visitor.visit(program);
     }
     catch { }
-    return Array.from(entries).map(specifier => toDeferResolveProductionEntry(specifier, { containingFilePath: options.configFilePath }));
+    return Array.from(entries).map(specifier => toDeferResolveProductionEntry(specifier));
 };

package/dist/plugins/stencil/index.js

@@ -1,8 +1,6 @@
 import scss from '../../compilers/scss.js';
-import { IMPORT_FLAGS } from '../../constants.js';
-import { getPropertyValues } from '../../typescript/ast-helpers.js';
-import { dirname, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { createComponentStyleUrlsVisitor } from '../_component-style-urls/component-style-urls-visitor.js';
 import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
 import { entry, resolveFromAST } from './resolveFromAST.js';
 const title = 'Stencil';
@@ -18,42 +16,7 @@ const registerCompilers = ({ hasDependency, registerCompiler }) => {
 };
 const registerVisitors = ({ ctx, registerVisitor }) => {
     registerVisitor(createCustomElementVisitor(ctx, isStencilSpecifier, { decoratorName: 'Component' }));
-    const componentNames = new Set();
-    registerVisitor({
-        Program() {
-            componentNames.clear();
-        },
-        ImportDeclaration(node) {
-            if (!isStencilSpecifier(node.source?.value))
-                return;
-            for (const spec of node.specifiers ?? []) {
-                if (spec.type === 'ImportSpecifier' &&
-                    spec.imported.type === 'Identifier' &&
-                    spec.imported.name === 'Component')
-                    componentNames.add(spec.local.name);
-            }
-        },
-        ClassDeclaration(node) {
-            resolveStyleUrls(node);
-        },
-    });
-    function resolveStyleUrls(node) {
-        const dir = dirname(ctx.filePath);
-        for (const decorator of node.decorators ?? []) {
-            const expr = decorator.expression;
-            if (expr?.type !== 'CallExpression')
-                continue;
-            if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
-                continue;
-            const arg = expr.arguments?.[0];
-            if (arg?.type !== 'ObjectExpression')
-                continue;
-            for (const url of getPropertyValues(arg, 'styleUrl'))
-                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
-            for (const url of getPropertyValues(arg, 'styleUrls'))
-                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
-        }
-    }
+    registerVisitor(createComponentStyleUrlsVisitor(ctx, isStencilSpecifier));
 };
 const plugin = {
     title,

package/dist/plugins/storybook/index.js

@@ -12,7 +12,7 @@ const restEntry = ['.{storybook,rnstorybook}/{manager,preview,index,vitest.setup
 const entry = [...restEntry, ...stories];
 const project = ['.{storybook,rnstorybook}/**/*.{js,jsx,ts,tsx,mts}'];
 const resolveConfig = async (localConfig, options) => {
-    const { cwd, configFileDir, configFilePath } = options;
+    const { cwd, configFileDir } = options;
     const strs = typeof localConfig?.stories === 'function' ? await localConfig.stories(stories) : localConfig?.stories;
     const relativePatterns = strs?.map(pattern => {
         if (typeof pattern === 'string')
@@ -37,9 +37,7 @@ const resolveConfig = async (localConfig, options) => {
     const viteConfigPath = typeof framework === 'object' &&
         framework?.name === '@storybook/react-vite' &&
         framework?.options?.builder?.viteConfigPath;
-    const configs = viteConfigPath
-        ? [toConfig('vite', viteConfigPath, { dir: cwd, containingFilePath: configFilePath })]
-        : [];
+    const configs = viteConfigPath ? [toConfig('vite', viteConfigPath, { dir: cwd })] : [];
     const hasVitestAddon = addons.some(addon => addon === '@storybook/addon-vitest');
     const coverageDeps = hasVitestAddon
         ? [

package/dist/plugins/sveltejs-package/helpers.js

@@ -1,6 +1,6 @@
 import parseArgs from '../../util/parse-args.js';
 import { parse } from 'unbash';
-import { getCommandWords, walkCommands } from '../../util/scripts.js';
+import { getCommandWords, collectCommands } from '../../util/scripts.js';
 const BIN = 'svelte-package';
 export const DEFAULT_INPUT = 'src/lib';
 export const DEFAULT_OUTPUT = 'dist';
@@ -16,7 +16,7 @@ export const parseScripts = (scripts) => {
         try {
             const parsed = parse(script);
             for (const statement of parsed.commands) {
-                for (const node of walkCommands(statement.command)) {
+                for (const node of collectCommands(statement.command)) {
                     if (node.name?.value === BIN)
                         out.push(parseCommandIO(getCommandWords(node).map(word => word.value)));
                 }

package/dist/plugins/taskfile/index.js

@@ -78,7 +78,7 @@ const extractScriptsFromTask = (task) => {
 const resolveConfig = async (localConfig, options) => {
     if (!localConfig || !options.configFilePath)
         return [];
-    const { configFilePath, getInputsFromScripts, isProduction, configFileDir } = options;
+    const { getInputsFromScripts, isProduction, configFileDir } = options;
     const inputs = [];
     if (localConfig.includes && typeof localConfig.includes === 'object') {
         for (const includeValue of Object.values(localConfig.includes)) {
@@ -89,17 +89,14 @@ const resolveConfig = async (localConfig, options) => {
                     : undefined;
             if (includePath) {
                 const resolvedPath = join(configFileDir, includePath);
-                inputs.push(toConfig('taskfile', relative(configFileDir, resolvedPath), { containingFilePath: configFilePath }));
+                inputs.push(toConfig('taskfile', relative(configFileDir, resolvedPath)));
             }
         }
     }
     if (localConfig.tasks && typeof localConfig.tasks === 'object') {
         for (const task of Object.values(localConfig.tasks)) {
             for (const script of extractScriptsFromTask(task)) {
-                for (const input of getInputsFromScripts([script], {
-                    optionalBinaries: true,
-                    containingFilePath: configFilePath,
-                })) {
+                for (const input of getInputsFromScripts([script], { optionalBinaries: true })) {
                     if (isProduction)
                         Object.assign(input, { optional: true });
                     inputs.push({ ...input, dir: configFileDir });

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

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