knip 5.42.0 → 5.42.2

package/dist/ConfigurationChief.d.ts

@@ -83,6 +83,7 @@ export declare class ConfigurationChief {
         cspell?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         cucumber?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         cypress?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "dependency-cruiser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         dotenv?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         drizzle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationValidator.d.ts

@@ -184,6 +184,19 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         }>]>>;
+        'dependency-cruiser': z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+            config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }>]>>;
         dotenv: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1266,6 +1279,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'dependency-cruiser'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1725,6 +1743,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'dependency-cruiser'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -2274,6 +2297,19 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>>;
+    'dependency-cruiser': z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>>;
     dotenv: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -3358,6 +3394,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'dependency-cruiser'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     dotenv?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -3823,6 +3864,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'dependency-cruiser'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -4285,6 +4331,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'dependency-cruiser'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     dotenv?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -4750,6 +4801,11 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'dependency-cruiser'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/IssueCollector.js

@@ -51,11 +51,13 @@ export class IssueCollector {
         if (this.isMatch(issue.filePath))
             return;
         const key = relative(this.cwd, issue.filePath);
-        issue.severity = this.rules[issue.type];
-        const issues = this.issues[issue.type];
+        const { type } = issue;
+        issue.severity = this.rules[type];
+        const issues = this.issues[type];
         issues[key] = issues[key] ?? {};
-        if (!issues[key][issue.symbol]) {
-            issues[key][issue.symbol] = issue;
+        const symbol = type.endsWith('Members') && issue.parentSymbol ? `${issue.parentSymbol}.${issue.symbol}` : issue.symbol;
+        if (!issues[key][symbol]) {
+            issues[key][symbol] = issue;
             this.counters[issue.type]++;
         }
         return issue;

package/dist/WorkspaceWorker.js

@@ -251,8 +251,9 @@ export class WorkspaceWorker {
                             if (hasResolveConfig) {
                                 const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
                                 for (const input of inputs) {
-                                    if (isConfigPattern(input))
+                                    if (isConfigPattern(input)) {
                                         handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
+                                    }
                                     addInput(input, configFilePath);
                                 }
                                 data.resolveConfig = inputs;

package/dist/binaries/package-manager/bun.js

@@ -2,10 +2,16 @@ import parseArgs from 'minimist';
 import { isFile } from '../../util/fs.js';
 import { toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
-const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade'];
-export const resolve = (_binary, args, { manifestScriptNames, cwd, fromArgs }) => {
+import { resolveX } from './bunx.js';
+const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade', 'x'];
+export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args);
     const [command, script] = parsed._;
+    if (command === 'x') {
+        const argsForX = args.filter(arg => arg !== 'x');
+        return resolveX(argsForX, options);
+    }
+    const { manifestScriptNames, cwd, fromArgs } = options;
     if (command === 'run' && manifestScriptNames.has(script))
         return [];
     if (manifestScriptNames.has(command) || commands.includes(command))

package/dist/binaries/package-manager/bunx.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+export declare const resolveX: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/bunx.js

@@ -0,0 +1,18 @@
+import parseArgs from 'minimist';
+import { toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
+import { argsFrom } from '../util.js';
+export const resolveX = (args, options) => {
+    const { fromArgs } = options;
+    const parsed = parseArgs(args);
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const command = parsed['shell-mode'] ? fromArgs([parsed['shell-mode']]) : [];
+    const restArgs = argsFrom(args, packageSpecifier);
+    const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
+    return [...dependency, ...packages.map(id => toDependency(id)), ...command, ...fromArgs(restArgs).slice(1)];
+};
+export const resolve = (_binary, args, options) => {
+    return resolveX(args, options);
+};

package/dist/binaries/package-manager/index.d.ts

@@ -1,8 +1,10 @@
 declare const _default: {
     bun: import("../../types/config.js").BinaryResolver;
+    bunx: import("../../types/config.js").BinaryResolver;
     npm: import("../../types/config.js").BinaryResolver;
     npx: import("../../types/config.js").BinaryResolver;
     pnpm: import("../../types/config.js").BinaryResolver;
+    pnpx: import("../../types/config.js").BinaryResolver;
     yarn: import("../../types/config.js").BinaryResolver;
 };
 export default _default;

package/dist/binaries/package-manager/index.js

@@ -1,12 +1,16 @@
 import * as bun from './bun.js';
+import * as bunx from './bunx.js';
 import * as npm from './npm.js';
 import * as npx from './npx.js';
 import * as pnpm from './pnpm.js';
+import * as pnpx from './pnpx.js';
 import * as yarn from './yarn.js';
 export default {
     bun: bun.resolve,
+    bunx: bunx.resolve,
     npm: npm.resolve,
     npx: npx.resolve,
     pnpm: pnpm.resolve,
+    pnpx: pnpx.resolve,
     yarn: yarn.resolve,
 };

package/dist/binaries/package-manager/npm.js

@@ -1,8 +1,7 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../../util/input.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs } = options;
     const parsed = parseArgs(args);
     const [command] = parsed._;
-    return [toBinary(_binary), ...(command !== 'exec' ? [] : fromArgs(parsed._.slice(1)))];
+    return command !== 'exec' ? [] : fromArgs(parsed._.slice(1));
 };

package/dist/binaries/package-manager/npx.js

@@ -15,7 +15,12 @@ export const resolve = (_binary, args, options) => {
     const command = parsed.call ? fromArgs([parsed.call]) : [];
     const restArgs = argsFrom(args, packageSpecifier);
     const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier);
-    const dependency = isBinary ? toBinary(specifier) : toDependency(specifier);
+    const dependency = isBinary ? toBinary(specifier) : toDependency(specifier, { optional: !parsed.no });
     const specifiers = dependency && !parsed.yes ? [dependency] : [];
-    return [toBinary(_binary), ...specifiers, ...packages.map(toDependency), ...command, ...fromArgs(restArgs).slice(1)];
+    return [
+        ...specifiers,
+        ...packages.map(id => toDependency(id, { optional: true })),
+        ...command,
+        ...fromArgs(restArgs).slice(1),
+    ];
 };

package/dist/binaries/package-manager/pnpm.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
 import { toBinary } from '../../util/input.js';
+import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
     'audit',
@@ -51,12 +52,17 @@ const commands = [
     'upgrade',
     'why',
 ];
-export const resolve = (_binary, args, { manifestScriptNames, fromArgs }) => {
+export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, {
         boolean: ['recursive', 'silent', 'shell-mode'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c' },
     });
     const [command, binary] = parsed._;
+    if (command === 'dlx') {
+        const argsForDlx = args.filter(arg => arg !== 'dlx');
+        return resolveDlx(argsForDlx, options);
+    }
+    const { manifestScriptNames, fromArgs } = options;
     if (manifestScriptNames.has(command) || commands.includes(command))
         return [];
     if (command === 'exec') {

package/dist/binaries/package-manager/pnpx.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+export declare const resolveDlx: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/pnpx.js

@@ -0,0 +1,18 @@
+import parseArgs from 'minimist';
+import { toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
+export const resolveDlx = (args, options) => {
+    const parsed = parseArgs(args, {
+        boolean: ['silent'],
+        alias: { package: 'p', 'shell-mode': 'c' },
+    });
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const command = parsed['shell-mode'] ? options.fromArgs([parsed['shell-mode']]) : [];
+    const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
+    return [...dependency, ...packages.map(id => toDependency(id, { optional: true })), ...command];
+};
+export const resolve = (_binary, args, options) => {
+    return resolveDlx(args, options);
+};

package/dist/binaries/package-manager/yarn.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../../util/input.js';
+import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
 const commands = [
     'add',
@@ -34,17 +35,40 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (_binary, args, { manifestScriptNames, fromArgs, cwd, rootCwd }) => {
+const resolveDlx = (args, options) => {
+    const parsed = parseArgs(args, {
+        boolean: ['quiet'],
+        alias: { package: 'p', quiet: 'q' },
+    });
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const command = specifier ? options.fromArgs(parsed._) : [];
+    return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
+};
+export const resolve = (_binary, args, options) => {
+    const { manifestScriptNames, fromArgs, cwd, rootCwd } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'] });
-    const [command, binary] = parsed._;
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
-    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
-        return [];
-    if (!dir && command === 'run' && manifestScriptNames.has(binary))
-        return [];
-    if (command === 'run' || command === 'exec')
-        return dir ? [{ ...toBinary(binary), dir }] : [toBinary(binary)];
+    const [command, binary] = parsed._;
+    if (command === 'run') {
+        if (manifestScriptNames.has(binary))
+            return [];
+        const bin = toBinary(binary, { optional: true });
+        if (dir)
+            Object.assign(bin, { dir });
+        return [bin];
+    }
     if (command === 'node')
         return fromArgs(parsed._);
-    return command ? (dir ? [{ ...toBinary(command), dir }] : [toBinary(command)]) : [];
+    if (command === 'dlx') {
+        const argsForDlx = args.filter(arg => arg !== 'dlx');
+        return resolveDlx(argsForDlx, options);
+    }
+    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
+        return [];
+    const bin = command === 'exec' ? toBinary(binary) : toBinary(command);
+    if (dir)
+        Object.assign(bin, { dir });
+    return [bin];
 };

package/dist/binaries/plugins.js

@@ -2,6 +2,7 @@ import parseArgs from 'minimist';
 import { pluginArgsMap } from '../plugins.js';
 import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';
+import { extractBinary } from '../util/modules.js';
 import { resolve as fallbackResolve } from './fallback.js';
 const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
@@ -31,8 +32,12 @@ export const resolve = (binary, _args, options) => {
         const id = parsed._[0];
         if (isGlobLike(id))
             positionals.push(toEntry(id));
-        else
-            positionals.push(toDeferResolveEntry(id));
+        else {
+            if (id.includes('node_modules/.bin/'))
+                positionals.push(toBinary(extractBinary(id)));
+            else
+                positionals.push(toDeferResolveEntry(id));
+        }
     }
     const mapToParsedKey = (id) => parsed[id];
     const resolved = compact(opts.resolve ? opts.resolve.flatMap(mapToParsedKey) : []);

package/dist/compilers/index.d.ts

@@ -73,6 +73,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'dependency-cruiser'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     dotenv?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -536,6 +541,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'dependency-cruiser'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         dotenv?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/index.js

@@ -251,7 +251,7 @@ export const main = async (unresolvedConfiguration) => {
             graph.set(filePath, file);
             if (scripts && scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
-                const manifestScriptNames = new Set();
+                const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const rootCwd = cwd;
                 const options = {
                     cwd: dirname(filePath),
@@ -260,11 +260,11 @@ export const main = async (unresolvedConfiguration) => {
                     dependencies,
                     manifestScriptNames,
                 };
-                const specifiers = _getInputsFromScripts(scripts, options);
-                for (const specifier of specifiers) {
-                    specifier.containingFilePath = filePath;
-                    specifier.dir = cwd;
-                    const specifierFilePath = getReferencedInternalFilePath(specifier, workspace);
+                const inputs = _getInputsFromScripts(scripts, options);
+                for (const input of inputs) {
+                    input.containingFilePath = filePath;
+                    input.dir = cwd;
+                    const specifierFilePath = getReferencedInternalFilePath(input, workspace);
                     if (specifierFilePath)
                         analyzeSourceFile(specifierFilePath, principal);
                 }

package/dist/plugins/angular/index.js

@@ -1,5 +1,6 @@
-import { toConfig, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { existsSync } from 'node:fs';
+import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
+import { isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import * as karma from '../karma/helpers.js';
 const title = 'Angular';
@@ -27,21 +28,31 @@ const resolveConfig = async (config, options) => {
             const defaultEntriesByOption = opts ? entriesByOption(opts) : new Map();
             const entriesByOptionByConfig = new Map(configs ? Object.entries(configs).map(([name, opts]) => [name, entriesByOption(opts)]) : []);
             const productionEntriesByOption = entriesByOptionByConfig.get(PRODUCTION_CONFIG_NAME) ?? new Map();
-            const normalizePath = (path) => join(cwd, path);
+            const isBuildTarget = targetName === BUILD_TARGET_NAME;
+            const maybeExternal = (option) => option === 'polyfills';
+            const toInput = (specifier, opts) => {
+                const normalizedPath = join(cwd, specifier);
+                if (opts.maybeExternal && !isInternal(specifier) && !existsSync(normalizedPath)) {
+                    return toDeferResolve(specifier);
+                }
+                return opts.isProduction ? toProductionEntry(normalizedPath) : toEntry(normalizedPath);
+            };
             for (const [configName, entriesByOption] of entriesByOptionByConfig.entries()) {
-                for (const entries of entriesByOption.values()) {
+                for (const [option, entries] of entriesByOption.entries()) {
                     for (const entry of entries) {
-                        inputs.add(targetName === BUILD_TARGET_NAME && configName === PRODUCTION_CONFIG_NAME
-                            ? toProductionEntry(normalizePath(entry))
-                            : toEntry(normalizePath(entry)));
+                        inputs.add(toInput(entry, {
+                            isProduction: isBuildTarget && configName === PRODUCTION_CONFIG_NAME,
+                            maybeExternal: maybeExternal(option),
+                        }));
                     }
                 }
             }
             for (const [option, entries] of defaultEntriesByOption.entries()) {
                 for (const entry of entries) {
-                    inputs.add(targetName === BUILD_TARGET_NAME && !productionEntriesByOption.get(option)?.length
-                        ? toProductionEntry(normalizePath(entry))
-                        : toEntry(normalizePath(entry)));
+                    inputs.add(toInput(entry, {
+                        isProduction: isBuildTarget && !productionEntriesByOption.get(option)?.length,
+                        maybeExternal: maybeExternal(option),
+                    }));
                 }
             }
             if (target.builder === '@angular-devkit/build-angular:karma' && opts) {
@@ -74,6 +85,11 @@ const entriesByOption = (opts) => new Map(Object.entries({
     scripts: 'scripts' in opts && opts.scripts && Array.isArray(opts.scripts)
         ? opts.scripts.map(scriptStringOrObject => typeof scriptStringOrObject === 'string' ? scriptStringOrObject : scriptStringOrObject.input)
         : [],
+    polyfills: 'polyfills' in opts && opts.polyfills
+        ? Array.isArray(opts.polyfills)
+            ? opts.polyfills
+            : [opts.polyfills]
+        : [],
     fileReplacements: 'fileReplacements' in opts && opts.fileReplacements && Array.isArray(opts.fileReplacements)
         ? opts.fileReplacements.map(fileReplacement => 'with' in fileReplacement ? fileReplacement.with : fileReplacement.replaceWith)
         : [],

package/dist/plugins/capacitor/index.js

@@ -11,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].map(toDependency);
+    return [...plugins, ...android, ...ios].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/changesets/index.js

@@ -10,7 +10,7 @@ const resolveConfig = config => {
         ? [config.changelog[0]]
         : typeof config.changelog === 'string'
             ? [config.changelog]
-            : []).map(toDependency);
+            : []).map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/commitlint/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (config) => {
                 ? [parserPreset.path ?? parserPreset]
                 : []
         : [];
-    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(toDependency);
+    return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(id => toDependency(id));
 };
 export default {
     title,

package/dist/plugins/dependency-cruiser/index.d.ts

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    args: {
+        binaries: string[];
+        config: boolean;
+    };
+};
+export default _default;

package/dist/plugins/dependency-cruiser/index.js

@@ -0,0 +1,16 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'dependency-cruiser';
+const enablers = ['dependency-cruiser'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.dependency-cruiser.{js,cjs,mjs,json}'];
+const args = {
+    binaries: ['depcruise', 'dependency-cruise', 'dependency-cruiser', 'depcruise-baseline'],
+    config: true,
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+};

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

@@ -1,4 +1,4 @@
 import type { PluginOptions } from '../../types/config.js';
 import { type Input } from '../../util/input.js';
 import type { ExpoConfig } from './types.js';
-export declare const getDependencies: (expoConfig: ExpoConfig, { manifest }: PluginOptions) => Promise<Input[]>;
+export declare const getDependencies: (localConfig: ExpoConfig, { manifest }: PluginOptions) => Promise<Input[]>;

package/dist/plugins/expo/helpers.js

@@ -1,6 +1,7 @@
 import { toDependency, toProductionDependency } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-export const getDependencies = async (expoConfig, { manifest }) => {
+export const getDependencies = async (localConfig, { manifest }) => {
+    const expoConfig = typeof localConfig === 'function' ? localConfig() : localConfig;
     const config = 'expo' in expoConfig ? expoConfig.expo : expoConfig;
     const platforms = config.platforms ?? ['ios', 'android'];
     const pluginPackages = config.plugins
@@ -9,7 +10,7 @@ export const getDependencies = async (expoConfig, { manifest }) => {
         return getPackageNameFromModuleSpecifier(pluginName);
     })
         .filter(Boolean) ?? [];
-    const inputs = new Set(pluginPackages.map(toDependency));
+    const inputs = new Set(pluginPackages.map(id => toDependency(id)));
     const allowedPackages = ['expo-atlas', 'expo-dev-client'];
     const allowedProductionPackages = ['expo-insights'];
     const manifestDependencies = Object.keys(manifest.dependencies ?? {});

package/dist/plugins/expo/index.js

@@ -8,7 +8,8 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['app.json', 'app.config.{ts,js}'];
 const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
 export const docs = { production };
-const resolveEntryPaths = async (expoConfig, { manifest }) => {
+const resolveEntryPaths = async (localConfig, { manifest }) => {
+    const expoConfig = typeof localConfig === 'function' ? localConfig() : localConfig;
     const config = 'expo' in expoConfig ? expoConfig.expo : expoConfig;
     let patterns = [];
     if (manifest.main === 'expo-router/entry') {

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

@@ -15,7 +15,8 @@ type AppConfig = {
     androidNavigationBar?: Record<string, unknown>;
     plugins?: (string | [string, Record<string, unknown>])[];
 };
-export type ExpoConfig = AppConfig | {
+type Config = AppConfig | {
     expo: AppConfig;
 };
+export type ExpoConfig = Config | (() => Config);
 export {};

package/dist/plugins/gatsby/index.js

@@ -26,7 +26,7 @@ const resolveConfig = async (localConfig, options) => {
         if (typeof _config.onCreateBabelConfig === 'function') {
             _config.onCreateBabelConfig({ actions });
         }
-        return Array.from(plugins).map(toDependency);
+        return Array.from(plugins).map(id => toDependency(id));
     }
     return [];
 };