knip 5.33.3 → 5.34.0

package/dist/index.js

@@ -6,19 +6,19 @@ import { IssueCollector } from './IssueCollector.js';
 import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
-import { _getDependenciesFromScripts } from './binaries/index.js';
+import { _getInputsFromScripts } from './binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
-import { getFilteredScripts } from './manifest/helpers.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { getOrCreateFileNode, updateImportMap } from './util/dependency-graph.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { _glob, negate } from './util/glob.js';
-import { getReferencedDependencyHandler } from './util/handle-dependency.js';
+import { getReferencedDependencyHandler } from './util/handle-referenced-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
+import { isConfigPattern, isEntry, isProductionEntry, toProductionEntry } from './util/input.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
 import { getPackageNameFromModuleSpecifier } from './util/modules.js';
 import { getEntryPathsFromManifest } from './util/package-json.js';
-import { dirname, join } from './util/path.js';
+import { dirname, isAbsolute, join, relative } from './util/path.js';
 import { findMatch } from './util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from './util/tag.js';
 import { augmentWorkspace, getToSourcePathHandler } from './util/to-source-path.js';
@@ -52,47 +52,39 @@ export const main = async (unresolvedConfiguration) => {
     const isReportClassMembers = report.classMembers;
     const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
     const collector = new IssueCollector({ cwd, rules, filters });
+    const allConfigFilePaths = new Set();
     const enabledPluginsStore = new Map();
     const o = () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors }));
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
     debugLogObject('*', 'Included workspace configs', o);
     const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
     const toSourceFilePath = getToSourcePathHandler(chief);
-    const handleReferencedDependency = getReferencedDependencyHandler(collector, deputy, chief);
+    const getReferencedInternalFilePath = getReferencedDependencyHandler(collector, deputy, chief, isGitIgnored);
     const shouldIgnore = getShouldIgnoreHandler(isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
     for (const workspace of workspaces) {
-        const { name, dir, ancestors, pkgName, manifestPath } = workspace;
-        streamer.cast(`Analyzing workspace ${name}...`);
+        const { name, dir, manifestPath } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
-        const { ignoreBinaries, ignoreDependencies } = chief.getIgnores(name);
         if (!manifest)
             continue;
+        const { ignoreBinaries, ignoreDependencies } = chief.getIgnores(name);
         deputy.addWorkspace({ name, cwd, dir, manifestPath, manifest, ignoreBinaries, ignoreDependencies });
+    }
+    for (const workspace of workspaces) {
+        const { name, dir, ancestors, pkgName } = workspace;
+        streamer.cast(`Analyzing workspace ${name}...`);
+        const manifest = chief.getManifestForWorkspace(name);
+        if (!manifest) {
+            continue;
+        }
         const dependencies = deputy.getDependencies(name);
         const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
         const extensions = getCompilerExtensions(compilers);
         const config = chief.getConfigForWorkspace(name, extensions);
-        const filteredScripts = getFilteredScripts({ isProduction, scripts: manifest.scripts });
-        const manifestScripts = Object.values(filteredScripts);
-        const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
-        const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(join(dir, tsConfigFile ?? 'tsconfig.json'));
+        const tsConfigFilePath = join(dir, tsConfigFile ?? 'tsconfig.json');
+        const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(tsConfigFilePath);
         if (isFile)
             augmentWorkspace(workspace, dir, compilerOptions);
-        const principal = factory.getPrincipal({
-            cwd: dir,
-            paths: config.paths,
-            isFile,
-            compilerOptions,
-            compilers,
-            pkgName,
-            isIsolateWorkspaces,
-            isSkipLibs,
-            isWatch,
-            toSourceFilePath,
-            isCache,
-            cacheLocation,
-        });
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -100,29 +92,64 @@ export const main = async (unresolvedConfiguration) => {
             config,
             manifest,
             dependencies,
+            getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
             isProduction,
             isStrict,
             rootIgnore: chief.config.ignore,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
+            ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
             isCache,
             cacheLocation,
+            allConfigFilePaths,
         });
         await worker.init();
-        principal.addEntryPaths(definitionPaths);
+        const deps = new Set();
         debugLogArray(name, 'Definition paths', definitionPaths);
+        for (const id of definitionPaths)
+            deps.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
         const ignore = worker.getIgnorePatterns();
         const sharedGlobOptions = { cwd, dir, gitignore };
         collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
-        const options = { manifestScriptNames, cwd: dir, dependencies };
-        const dependenciesFromManifest = _getDependenciesFromScripts(manifestScripts, options);
-        principal.addReferencedDependencies(name, new Set(dependenciesFromManifest.map(id => [manifestPath, id])));
         const entryPathsFromManifest = await getEntryPathsFromManifest(manifest, { ...sharedGlobOptions, ignore });
         debugLogArray(name, 'Entry paths in package.json', entryPathsFromManifest);
-        principal.addEntryPaths(entryPathsFromManifest);
-        const { referencedDependencies, enabledPlugins, entryFilePatterns, productionEntryFilePatterns } = await worker.findDependenciesByPlugins();
-        enabledPluginsStore.set(name, enabledPlugins);
-        principal.addReferencedDependencies(name, referencedDependencies);
+        for (const id of entryPathsFromManifest.map(id => toProductionEntry(id)))
+            deps.add(id);
+        const dependenciesFromPlugins = await worker.findDependenciesByPlugins();
+        for (const id of dependenciesFromPlugins)
+            deps.add(id);
+        enabledPluginsStore.set(name, worker.enabledPlugins);
+        const principal = factory.createPrincipal({
+            cwd: dir,
+            paths: config.paths,
+            isFile,
+            compilerOptions,
+            compilers,
+            pkgName,
+            isIsolateWorkspaces,
+            isSkipLibs,
+            isWatch,
+            toSourceFilePath,
+            isCache,
+            cacheLocation,
+        });
+        const entryFilePatterns = new Set();
+        const productionEntryFilePatterns = new Set();
+        for (const dependency of deps) {
+            const s = dependency.specifier;
+            if (isEntry(dependency)) {
+                entryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+            }
+            else if (isProductionEntry(dependency)) {
+                productionEntryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+            }
+            else if (!isConfigPattern(dependency)) {
+                const ws = (dependency.containingFilePath && chief.findWorkspaceByFilePath(dependency.containingFilePath)) || workspace;
+                const specifierFilePath = getReferencedInternalFilePath(dependency, ws);
+                if (specifierFilePath)
+                    principal.addEntryPath(specifierFilePath);
+            }
+        }
         if (isProduction) {
             const negatedEntryPatterns = Array.from(entryFilePatterns).map(negate);
             {
@@ -160,7 +187,7 @@ export const main = async (unresolvedConfiguration) => {
                     principal.addProjectPath(projectPath);
             }
             {
-                const patterns = [...entryFilePatterns, ...productionEntryFilePatterns];
+                const patterns = worker.getPluginEntryFilePatterns([...entryFilePatterns, ...productionEntryFilePatterns]);
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(name, 'Plugin entry paths', pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
@@ -220,12 +247,21 @@ export const main = async (unresolvedConfiguration) => {
             file.internalImportCache = imports.internal;
             graph.set(filePath, file);
             if (scripts && scripts.size > 0) {
-                const cwd = dirname(filePath);
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set();
-                const specifiers = _getDependenciesFromScripts(scripts, { cwd, manifestScriptNames, dependencies });
+                const rootCwd = cwd;
+                const options = {
+                    cwd: dirname(filePath),
+                    rootCwd,
+                    containingFilePath: filePath,
+                    dependencies,
+                    manifestScriptNames,
+                };
+                const specifiers = _getInputsFromScripts(scripts, options);
                 for (const specifier of specifiers) {
-                    const specifierFilePath = handleReferencedDependency(specifier, filePath, workspace);
+                    specifier.containingFilePath = filePath;
+                    specifier.dir = cwd;
+                    const specifierFilePath = getReferencedInternalFilePath(specifier, workspace);
                     if (specifierFilePath)
                         analyzeSourceFile(specifierFilePath, principal);
                 }
@@ -234,14 +270,6 @@ export const main = async (unresolvedConfiguration) => {
     };
     for (const principal of principals) {
         principal.init();
-        for (const [containingFilePath, specifier, workspaceName] of principal.referencedDependencies) {
-            const workspace = chief.findWorkspaceByName(workspaceName);
-            if (workspace) {
-                const specifierFilePath = handleReferencedDependency(specifier, containingFilePath, workspace);
-                if (specifierFilePath && !isGitIgnored(specifierFilePath))
-                    principal.addEntryPath(specifierFilePath);
-            }
-        }
         streamer.cast('Running async compilers...');
         await principal.runAsyncCompilers();
         streamer.cast('Analyzing source files...');

package/dist/manifest/helpers.d.ts

@@ -5,9 +5,5 @@ type LoadPackageManifestOptions = {
     cwd: string;
 };
 export declare const loadPackageManifest: ({ dir, packageName, cwd }: LoadPackageManifestOptions) => any;
-type GetFilteredScriptsOptions = {
-    isProduction: boolean;
-    scripts?: Scripts;
-};
-export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => Scripts;
+export declare const getFilteredScripts: (scripts: Scripts) => Scripts[];
 export {};

package/dist/manifest/helpers.js

@@ -14,16 +14,17 @@ export const loadPackageManifest = ({ dir, packageName, cwd }) => {
         }
     }
 };
-export const getFilteredScripts = ({ isProduction, scripts }) => {
+export const getFilteredScripts = (scripts) => {
     if (!scripts)
-        return {};
-    if (!isProduction)
-        return scripts;
+        return [{}, {}];
     const scriptFilter = new Set(['start', 'postinstall']);
-    const filteredScripts = {};
+    const productionScripts = {};
+    const developmentScripts = {};
     for (const scriptName in scripts) {
         if (scriptFilter.has(scriptName))
-            filteredScripts[scriptName] = scripts[scriptName];
+            productionScripts[scriptName] = scripts[scriptName];
+        else
+            developmentScripts[scriptName] = scripts[scriptName];
     }
-    return filteredScripts;
+    return [productionScripts, developmentScripts];
 };

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

@@ -1,8 +1,8 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { PluginConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: import("#p/types/config.js").IgnorePatterns;
+    enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];

package/dist/plugins/_template/index.js

@@ -1,4 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDeferResolve } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = '_template';
 const enablers = ['__PLUGIN_NAME__'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -6,8 +7,8 @@ const config = [];
 const entry = [];
 const production = [];
 const resolveConfig = async (config) => {
-    const dependencies = config?.plugins ?? [];
-    return [...dependencies];
+    const inputs = config?.plugins ?? [];
+    return [...inputs].map(toDeferResolve);
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { AngularCLIWorkspaceConfiguration } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/angular/index.js

@@ -1,16 +1,16 @@
-import { join } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
-import { toProductionEntryPattern } from '#p/util/protocols.js';
+import { toConfig, toDependency, toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Angular';
 const enablers = ['@angular/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['angular.json'];
 const production = [];
 const resolveConfig = async (config, options) => {
-    const { cwd } = options;
+    const { cwd, configFilePath } = options;
     if (!config?.projects)
         return [];
-    const dependencies = new Set();
+    const inputs = new Set();
     for (const project of Object.values(config.projects)) {
         if (!project.architect)
             return [];
@@ -18,23 +18,26 @@ const resolveConfig = async (config, options) => {
             const { options: opts } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];
             if (typeof packageName === 'string')
-                dependencies.add(packageName);
+                inputs.add(toDependency(packageName));
             if (opts) {
                 if ('main' in opts && typeof opts.main === 'string') {
-                    dependencies.add(toProductionEntryPattern(join(cwd, opts.main)));
+                    inputs.add(toProductionEntry(join(cwd, opts.main)));
                 }
                 if ('browser' in opts && typeof opts.browser === 'string') {
-                    dependencies.add(toProductionEntryPattern(join(cwd, opts.browser)));
+                    inputs.add(toProductionEntry(join(cwd, opts.browser)));
                 }
                 if ('ssr' in opts && opts.ssr && typeof opts.ssr === 'object') {
                     if ('entry' in opts.ssr && typeof opts.ssr.entry === 'string') {
-                        dependencies.add(toProductionEntryPattern(join(cwd, opts.ssr.entry)));
+                        inputs.add(toProductionEntry(join(cwd, opts.ssr.entry)));
                     }
                 }
+                if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
+                    inputs.add(toConfig('typescript', opts.tsConfig, configFilePath));
+                }
             }
         }
     }
-    return Array.from(dependencies);
+    return Array.from(inputs);
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, Resolve } from '#p/types/plugins.js';
+import type { IsPluginEnabled, Resolve } from '../../types/config.js';
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/astro/index.js

@@ -1,18 +1,19 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['astro.config.{js,cjs,mjs,ts}', 'src/content/config.ts'];
 const production = ['src/pages/**/*.{astro,mdx,js,ts}', 'src/content/**/*.mdx'];
 const resolve = options => {
-    const { isProduction, manifest } = options;
-    const dependencies = [];
+    const { manifest, isProduction } = options;
+    const inputs = [];
     if (!isProduction &&
         manifest.scripts &&
         Object.values(manifest.scripts).some(script => /(?<=^|\s)astro(\s|\s.+\s)check(?=\s|$)/.test(script))) {
-        dependencies.push('@astrojs/check');
+        inputs.push(toDependency('@astrojs/check'));
     }
-    return dependencies;
+    return inputs;
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import type { AvaConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/ava/index.js

@@ -1,5 +1,5 @@
-import { getDependenciesFromScripts, hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Ava';
 const enablers = ['ava'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -19,7 +19,7 @@ const entry = [
 const resolveEntryPaths = localConfig => {
     if (typeof localConfig === 'function')
         localConfig = localConfig();
-    return (localConfig?.files ?? []).map(toEntryPattern);
+    return (localConfig?.files ?? []).map(toEntry);
 };
 const resolveConfig = async (localConfig, options) => {
     if (typeof localConfig === 'function')
@@ -27,8 +27,7 @@ const resolveConfig = async (localConfig, options) => {
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    const dependencies = getDependenciesFromScripts([fakeCommand], { ...options, knownGlobalsOnly: true });
-    return [...dependencies];
+    return options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true });
 };
 export default {
     title,

package/dist/plugins/babel/helpers.js

@@ -1,4 +1,4 @@
-import { isAbsolute, isInternal } from '#p/util/path.js';
+import { isAbsolute, isInternal } from '../../util/path.js';
 export const resolveName = (identifier, namespace) => {
     if (isAbsolute(identifier) || isInternal(identifier))
         return identifier;

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

@@ -1,6 +1,7 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import { type Input } from '../../util/input.js';
 import type { BabelConfig, BabelConfigObj } from './types.js';
-export declare const getDependenciesFromConfig: (config: BabelConfigObj) => string[];
+export declare const getDependenciesFromConfig: (config: BabelConfigObj) => Input[];
 declare const _default: {
     title: string;
     enablers: RegExp[];

package/dist/plugins/babel/index.js

@@ -1,5 +1,6 @@
-import { compact } from '#p/util/array.js';
-import { hasDependency } from '#p/util/plugin.js';
+import { compact } from '../../util/array.js';
+import { toDeferResolve } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 import { api, resolveName } from './helpers.js';
 const title = 'Babel';
 const enablers = [/^@babel\//];
@@ -11,7 +12,7 @@ export const getDependenciesFromConfig = (config) => {
     const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependenciesFromConfig) : [];
-    return compact([...presets, ...plugins, ...nested, ...overrides]);
+    return compact([...presets.map(toDeferResolve), ...plugins.map(toDeferResolve), ...nested, ...overrides]);
 };
 const resolveConfig = async (config) => {
     if (typeof config === 'function')

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

@@ -0,0 +1,10 @@
+import type { ParsedArgs } from 'minimist';
+declare const _default: {
+    title: string;
+    args: {
+        args: (args: string[]) => string[];
+        boolean: string[];
+        fromArgs: (parsed: ParsedArgs, args: string[]) => string[];
+    };
+};
+export default _default;

package/dist/plugins/c8/index.js

@@ -0,0 +1,11 @@
+import { argsFrom } from '../../binaries/util.js';
+const title = 'c8';
+const args = {
+    args: (args) => args.filter(arg => arg !== 'check-coverage'),
+    boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],
+    fromArgs: (parsed, args) => argsFrom(args, parsed._[0]),
+};
+export default {
+    title,
+    args,
+};

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CapacitorConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/capacitor/index.js

@@ -1,6 +1,7 @@
-import { isFile } from '#p/util/fs.js';
-import { join } from '#p/util/path.js';
-import { hasDependency } from '#p/util/plugin.js';
+import { isFile } from '../../util/fs.js';
+import { toDependency } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Capacitor';
 const enablers = [/^@capacitor\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -10,7 +11,7 @@ const resolveConfig = async (config, { configFileDir }) => {
     const plugins = config.includePlugins ?? [];
     const android = (await exists('android/capacitor.settings.gradle')) ? ['@capacitor/android'] : [];
     const ios = (await exists('ios/App/Podfile')) ? ['@capacitor/ios'] : [];
-    return [...plugins, ...android, ...ios];
+    return [...plugins, ...android, ...ios].map(toDependency);
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { ChangesetsConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/changesets/index.js

@@ -1,14 +1,15 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Changesets';
 const enablers = ['@changesets/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['.changeset/config.json'];
 const resolveConfig = config => {
-    return Array.isArray(config.changelog)
+    return (Array.isArray(config.changelog)
         ? [config.changelog[0]]
         : typeof config.changelog === 'string'
             ? [config.changelog]
-            : [];
+            : []).map(toDependency);
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CommitizenConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/commitizen/index.js

@@ -1,11 +1,12 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Commitizen';
 const enablers = ['commitizen'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'config.commitizen';
 const config = ['.czrc', '.cz.json', 'package.json'];
 const resolveConfig = config => {
-    return config.path ? [config.path] : [];
+    return config.path ? [toDependency(config.path)] : [];
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CommitLintConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/commitlint/index.js

@@ -1,4 +1,6 @@
-import { hasDependency, toCosmiconfig } from '#p/util/plugin.js';
+import { toDependency } from '../../util/input.js';
+import { toCosmiconfig } from '../../util/plugin-config.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'commitlint';
 const enablers = ['@commitlint/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -19,7 +21,7 @@ const resolveConfig = async (config) => {
                 ? [parserPreset.path ?? parserPreset]
                 : []
         : [];
-    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths];
+    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(toDependency);
 };
 export default {
     title,

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CSpellConfig } from './types.js';
 declare const _default: {
     title: string;

package/dist/plugins/cspell/index.js

@@ -1,4 +1,5 @@
-import { hasDependency } from '#p/util/plugin.js';
+import { toDeferResolve } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'CSpell';
 const enablers = ['cspell'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -9,7 +10,7 @@ const config = [
     'c{s,S}pell.json',
 ];
 const resolveConfig = config => {
-    return config.import ?? [];
+    return (config.import ?? []).map(toDeferResolve);
 };
 export default {
     title,

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

@@ -1,8 +1,8 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
 import type { CucumberConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: import("#p/types/config.js").IgnorePatterns;
+    enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];

package/dist/plugins/cucumber/index.js

@@ -1,17 +1,17 @@
-import { hasDependency } from '#p/util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { toDeferResolve, toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
 const title = 'Cucumber';
 const enablers = ['@cucumber/cucumber'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['cucumber.{json,yaml,yml,js,cjs,mjs}'];
 const entry = ['features/**/*.@(js|cjs|mjs)'];
 const resolveEntryPaths = config => {
-    return (config?.import ? config.import : []).map(toEntryPattern);
+    return (config?.import ? config.import : []).map(toEntry);
 };
 const resolveConfig = config => {
     const formatters = config?.format ? config.format : [];
     const requires = config?.require ? config.require : [];
-    return [...formatters, ...requires];
+    return [...formatters, ...requires].map(toDeferResolve);
 };
 export default {
     title,

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

@@ -1,3 +1,3 @@
-import type { PluginOptions } from '#p/types/plugins.js';
+import type { PluginOptions } from '../../types/config.js';
 import type { CypressConfig } from './types.js';
 export declare const resolveDependencies: (config: CypressConfig, options: PluginOptions) => Promise<string[]>;